@verdant-web/server 3.3.11 → 4.0.1

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

@@ -1,34 +1,34 @@
 import {
 	AckMessage,
+	applyOperations,
 	ClientMessage,
 	DocumentBaseline,
 	EventSubscriber,
 	HeartbeatMessage,
+	isFileRef,
+	isObjectRef,
 	Operation,
 	OperationMessage,
 	PresenceUpdateMessage,
 	Ref,
 	ReplicaType,
-	SyncMessage,
-	applyOperations,
-	isFileRef,
-	isObjectRef,
 	rewriteAuthzOriginator,
+	SyncMessage,
 } from '@verdant-web/common';
-import { MessageSender } from './MessageSender.js';
-import { Presence } from './Presence.js';
-import { UserProfileLoader } from './Profiles.js';
-import { TokenInfo } from './TokenVerifier.js';
-import { FileStorage } from './files/FileStorage.js';
-import { Storage } from './storage/Storage.js';
+import { MessageSender } from '../connections/MessageSender.js';
+import { Presence } from '../connections/Presence.js';
+import { FileInfo, FileStorageLibraryDelegate } from '../files/FileStorage.js';
+import { Logger } from '../logger.js';
+import { Storage } from '../storage/Storage.js';
+import { TokenInfo } from '../TokenVerifier.js';
 import {
 	LibraryInfo,
 	StoredDocumentBaseline,
 	StoredOperation,
 	StoredReplicaInfo,
-} from './types.js';
+} from '../types.js';
 
-export type ServerLibraryEvents = {
+export type LibraryEvents = {
 	changes: (
 		info: TokenInfo,
 		operations: Operation[],
@@ -36,55 +36,63 @@ export type ServerLibraryEvents = {
 	) => void;
 };
 
-export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
+export interface LibraryFileInfo {
+	id: string;
+	name: string;
+	type: string;
+	url: string | null;
+	libraryId: string;
+}
+
+export class Library {
 	private storage;
 	private sender;
-	private profiles;
-	private presences;
 	private disableRebasing: boolean;
-	private fileStorage: FileStorage | undefined;
+	private fileStorage;
+	private events;
+	private id: string;
+	private presence: Presence;
+
+	private log: Logger;
 
-	private log: (...args: any[]) => void;
 	constructor({
 		storage,
 		sender,
-		profiles,
 		log = () => {},
 		disableRebasing,
 		fileStorage,
+		events,
+		id,
+		presence,
 	}: {
 		storage: Storage;
 		sender: MessageSender;
-		profiles: UserProfileLoader<any>;
-		log?: (...args: any[]) => void;
+		log?: Logger;
 		disableRebasing?: boolean;
-		fileStorage?: FileStorage;
+		fileStorage?: FileStorageLibraryDelegate;
+		events?: EventSubscriber<LibraryEvents>;
+		id: string;
+		presence: Presence;
 	}) {
-		super();
-
+		this.id = id;
+		this.storage = storage;
+		this.sender = sender;
 		this.log = log;
 		this.disableRebasing = !!disableRebasing;
-		this.sender = sender;
-		this.profiles = profiles;
-		this.presences = new Presence(profiles);
-		this.storage = storage;
 		this.fileStorage = fileStorage;
-		this.presences.on('lost', this.onPresenceLost);
+		this.events = events;
+		this.presence = presence;
+		this.presence.subscribe('lost', this.onPresenceLost);
 	}
 
-	/**
-	 * Validates a user's access to a replica. If the replica does not
-	 * exist, a user may create it. But if it does exist, its user (clientId)
-	 * must match the user making the request.
-	 */
 	private validateReplicaAccess = async (
 		replicaId: string,
 		clientKey: string,
 		info: TokenInfo,
 	) => {
-		const replica = await this.storage.replicas.get(info.libraryId, replicaId);
+		const replica = await this.storage.replicas.get(replicaId);
 		if (replica && replica.clientId !== info.userId) {
-			this.sender.send(info.libraryId, clientKey, {
+			this.sender.respond(clientKey, {
 				type: 'forbidden',
 			});
 			return false;
@@ -99,18 +107,22 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		);
 	};
 
-	receive = async (
+	handleMessage = async (
 		message: ClientMessage,
 		clientKey: string,
 		info: TokenInfo,
 	) => {
-		await this.storage.ready;
+		if (message.type === 'heartbeat') {
+			this.handleHeartbeat(message, clientKey, info);
+			return;
+		}
 
 		const allowed = await this.validateReplicaAccess(
 			message.replicaId,
 			clientKey,
 			info,
 		);
+
 		if (!allowed) return;
 
 		switch (message.type) {
@@ -123,14 +135,11 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 			case 'ack':
 				await this.handleAck(message, clientKey, info);
 				break;
-			case 'heartbeat':
-				await this.handleHeartbeat(message, clientKey, info);
-				break;
 			case 'presence-update':
 				await this.handlePresenceUpdate(message, clientKey, info);
 				break;
 			default:
-				this.log('Unknown message type', (message as any).type);
+				this.log('error', 'Unknown message type', (message as any).type);
 				break;
 		}
 		// a bit fragile - skipping presence-update since currently
@@ -138,15 +147,39 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		// sees a recent last seen for the replica even if it was
 		// truant before the presence-update.
 		if (message.type !== 'presence-update') {
-			await this.storage.replicas.updateLastSeen(
-				info.libraryId,
-				message.replicaId,
-			);
+			await this.storage.replicas.updateLastSeen(message.replicaId);
 		}
 	};
 
-	remove = (libraryId: string, replicaId: string) => {
-		this.presences.removeReplica(libraryId, replicaId);
+	private rebroadcastOperations = async (
+		libraryId: string,
+		clientKey: string,
+		replicaId: string,
+		ops: Operation[],
+		baselines?: DocumentBaseline[],
+	) => {
+		if (ops.length === 0 && !baselines?.length) return;
+
+		this.log(
+			'info',
+			'Rebroadcasting',
+			ops.length,
+			'operations',
+			baselines?.length ?? 0,
+			'baselines',
+		);
+
+		this.sender.broadcast(
+			{
+				type: 'op-re',
+				operations: ops,
+				baselines,
+				replicaId,
+				globalAckTimestamp:
+					(await this.storage.replicas.getGlobalAck()) ?? undefined,
+			},
+			[clientKey],
+		);
 	};
 
 	private handleOperation = async (
@@ -157,7 +190,7 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		if (!message.operations.length) return;
 
 		if (!this.hasWriteAccess(info)) {
-			this.sender.send(info.libraryId, clientKey, {
+			this.sender.respond(clientKey, {
 				type: 'forbidden',
 			});
 			return;
@@ -175,7 +208,6 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 
 		// first, record the replica's serverOrder before insertion.
 		const replicaInfo = await this.storage.replicas.getOrCreate(
-			info.libraryId,
 			message.replicaId,
 			{
 				userId: info.userId,
@@ -183,7 +215,6 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 			},
 		);
 		const newServerOrder = await this.storage.operations.insertAll(
-			info.libraryId,
 			message.replicaId,
 			message.operations,
 		);
@@ -193,10 +224,10 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 			message.operations.length,
 		);
 
-		this.enqueueRebase(info.libraryId);
+		this.enqueueRebase();
 
 		// tell sender we got and processed their operation
-		this.sender.send(info.libraryId, clientKey, {
+		this.sender.respond(clientKey, {
 			type: 'server-ack',
 			timestamp: message.timestamp,
 		});
@@ -207,7 +238,7 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 			info,
 		);
 
-		this.emit(`changes`, info, message.operations, []);
+		this.events?.emit(`changes`, info, message.operations, []);
 	};
 
 	/**
@@ -225,7 +256,6 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 			insertedOperationsCount
 		) {
 			await this.storage.replicas.updateAckedServerOrder(
-				replicaInfo.libraryId,
 				replicaInfo.id,
 				newServerOrder,
 			);
@@ -239,38 +269,6 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		}
 	};
 
-	private rebroadcastOperations = async (
-		libraryId: string,
-		clientKey: string,
-		replicaId: string,
-		ops: Operation[],
-		baselines?: DocumentBaseline[],
-	) => {
-		if (ops.length === 0 && !baselines?.length) return;
-
-		this.log(
-			'info',
-			'Rebroadcasting',
-			ops.length,
-			'operations',
-			baselines?.length ?? 0,
-			'baselines',
-		);
-
-		this.sender.broadcast(
-			libraryId,
-			{
-				type: 'op-re',
-				operations: ops,
-				baselines,
-				replicaId,
-				globalAckTimestamp:
-					(await this.storage.replicas.getGlobalAck(libraryId)) ?? undefined,
-			},
-			[clientKey],
-		);
-	};
-
 	private handleSync = async (
 		message: SyncMessage,
 		clientKey: string,
@@ -284,7 +282,7 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 			!this.hasWriteAccess(info) &&
 			(message.operations.length > 0 || message.baselines.length > 0)
 		) {
-			this.sender.send(info.libraryId, clientKey, {
+			this.sender.respond(clientKey, {
 				type: 'forbidden',
 			});
 			this.log('warn', 'sync with changes from read-only replica', replicaId);
@@ -293,11 +291,11 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 
 		if (message.resyncAll) {
 			// forget our local understanding of the replica and reset it
-			await this.storage.replicas.delete(info.libraryId, replicaId);
+			await this.storage.replicas.delete(replicaId);
 		}
 
 		const { status, replicaInfo: clientReplicaInfo } =
-			await this.storage.replicas.getOrCreate(info.libraryId, replicaId, info);
+			await this.storage.replicas.getOrCreate(replicaId, info);
 
 		this.log(
 			'info',
@@ -309,7 +307,7 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		let overrideTruant = false;
 		if (status === 'truant') {
 			const latestServerOrder =
-				await this.storage.operations.getLatestServerOrder(info.libraryId);
+				await this.storage.operations.getLatestServerOrder();
 			if (clientReplicaInfo.ackedServerOrder >= latestServerOrder) {
 				overrideTruant = true;
 				this.log(
@@ -321,7 +319,6 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 
 		// lookup operations after the last ack the client gave us
 		const ops = await this.storage.operations.getAfterServerOrder(
-			info.libraryId,
 			clientReplicaInfo.ackedServerOrder,
 		);
 
@@ -336,7 +333,7 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		// 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)
+			? await this.storage.baselines.getAll()
 			: [];
 
 		// We detect that a library is new by checking if it has any history.
@@ -377,7 +374,7 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 				'Detected local data is incomplete, requesting full history from replica',
 				replicaId,
 			);
-			this.sender.send(info.libraryId, clientKey, {
+			this.sender.respond(clientKey, {
 				type: 'need-since',
 				since: null,
 			});
@@ -412,7 +409,7 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		// we are not overwriting the replica's data
 		if (!overwriteReplicaData) {
 			// store all incoming operations and baselines
-			await this.storage.baselines.insertAll(info.libraryId, message.baselines);
+			await this.storage.baselines.insertAll(message.baselines);
 
 			this.log(
 				'debug',
@@ -423,7 +420,6 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 				'operations',
 			);
 			const newServerOrder = await this.storage.operations.insertAll(
-				info.libraryId,
 				replicaId,
 				message.operations,
 			);
@@ -433,7 +429,6 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 				message.operations.length,
 			);
 			await this.storage.replicas.updateAcknowledgedLogicalTime(
-				info.libraryId,
 				replicaId,
 				message.timestamp,
 			);
@@ -450,7 +445,12 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 				isEmptyLibrary ? message.baselines : undefined,
 			);
 			if (message.operations.length || message.baselines.length) {
-				this.emit(`changes`, info, message.operations, message.baselines);
+				this.events?.emit(
+					`changes`,
+					info,
+					message.operations,
+					message.baselines,
+				);
 			}
 		}
 
@@ -476,25 +476,32 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 			'operations and',
 			baselines.length,
 			'baselines',
+			'to client key',
+			clientKey,
 		);
 
 		// mutating baselines/operations to remove extra data -
 		// mutating just to save on allocations here.
 
-		this.sender.send(info.libraryId, clientKey, {
-			type: 'sync-resp',
-			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
-			// send its own history to us.
-			overwriteLocalData: overwriteReplicaData,
-			ackedTimestamp: message.timestamp,
-			ackThisNonce,
-		});
+		try {
+			this.sender.respond(clientKey, {
+				type: 'sync-resp',
+				operations: this.removeOperationExtras(ops),
+				baselines: this.removeBaselineExtras(baselines),
+				globalAckTimestamp:
+					(await this.storage.replicas.getGlobalAck()) ?? undefined,
+				peerPresence: this.presence.all(),
+				// 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.
+				overwriteLocalData: overwriteReplicaData,
+				ackedTimestamp: message.timestamp,
+				ackThisNonce,
+			});
+		} catch (err) {
+			this.log('error', err);
+			throw err;
+		}
 	};
 
 	private createAckNonce = (serverOrder: number): string | undefined => {
@@ -511,6 +518,7 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 				Buffer.from(message.nonce, 'base64').toString('utf8'),
 			);
 			this.log(
+				'debug',
 				'Ack from',
 				message.replicaId,
 				'(user',
@@ -526,21 +534,17 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 
 			const replicaId = message.replicaId;
 			await this.storage.replicas.updateAckedServerOrder(
-				info.libraryId,
 				replicaId,
 				decodedNonce,
 			);
 		} else if (message.timestamp) {
 			await this.storage.replicas.acknowledgeOperation(
-				info.libraryId,
 				message.replicaId,
 				message.timestamp,
 			);
-			const globalAck = await this.storage.replicas.getGlobalAck(
-				info.libraryId,
-			);
+			const globalAck = await this.storage.replicas.getGlobalAck();
 			if (globalAck) {
-				this.sender.broadcast(info.libraryId, {
+				this.sender.broadcast({
 					type: 'global-ack',
 					timestamp: globalAck,
 				});
@@ -555,16 +559,12 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		ignoreClientKeys: string[] = [],
 	) => {
 		await this.storage.replicas.updateAcknowledgedLogicalTime(
-			info.libraryId,
 			replicaId,
 			timestamp,
 		);
-		const newGlobalAck = await this.storage.replicas.getGlobalAck(
-			info.libraryId,
-		);
+		const newGlobalAck = await this.storage.replicas.getGlobalAck();
 		if (newGlobalAck) {
 			this.sender.broadcast(
-				info.libraryId,
 				{
 					type: 'global-ack',
 					timestamp: newGlobalAck,
@@ -575,15 +575,15 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 	};
 
 	private pendingRebaseTimeout: NodeJS.Timeout | null = null;
-	private enqueueRebase = (libraryId: string) => {
+	private enqueueRebase = () => {
 		if (this.disableRebasing) return;
 
 		if (!this.pendingRebaseTimeout) {
-			setTimeout(() => this.rebase(libraryId), 0);
+			setTimeout(() => this.rebase(), 0);
 		}
 	};
 
-	private rebase = async (libraryId: string) => {
+	private rebase = async () => {
 		if (this.disableRebasing) return;
 
 		this.log('debug', 'Performing rebase check');
@@ -604,15 +604,13 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		// for global ack, to determine consensus, also allow
 		// for all actively connected replicas to ack regardless of their
 		// type.
-		const activeReplicaIds = Object.values(this.presences.all(libraryId)).map(
+		const activeReplicaIds = Object.values(this.presence.all()).map(
 			(p) => p.replicaId,
 		);
-		const globalAck = await this.storage.replicas.getGlobalAck(
-			libraryId,
-			activeReplicaIds,
-		);
+		const globalAck =
+			await this.storage.replicas.getGlobalAck(activeReplicaIds);
 		const globalServerOrder =
-			await this.storage.replicas.getEarliestAckedServerOrder(libraryId);
+			await this.storage.replicas.getEarliestAckedServerOrder();
 
 		if (!globalAck) {
 			this.log('debug', 'No global ack, skipping rebase');
@@ -625,10 +623,8 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		}
 
 		// these are in forward chronological order
-		const ops = await this.storage.operations.getBeforeServerOrder(
-			libraryId,
-			globalServerOrder,
-		);
+		const ops =
+			await this.storage.operations.getBeforeServerOrder(globalServerOrder);
 
 		const opsToApply: Record<string, StoredOperation[]> = {};
 		// if we encounter a sequential operation in history which does
@@ -648,18 +644,17 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 
 		const deletedRefs = new Array<Ref>();
 		for (const [documentId, ops] of Object.entries(opsToApply)) {
-			this.log('Rebasing', documentId);
+			this.log('debug', 'Rebasing', documentId);
 			await this.storage.baselines.applyOperations(
-				libraryId,
 				documentId,
 				ops,
 				deletedRefs,
 			);
-			await this.storage.operations.delete(libraryId, ops);
+			await this.storage.operations.delete(ops);
 		}
 
 		// hint to clients they can rebase too
-		this.sender.broadcast(libraryId, {
+		this.sender.broadcast({
 			type: 'global-ack',
 			timestamp: globalAck,
 		});
@@ -668,9 +663,7 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		await Promise.all(
 			deletedRefs
 				.filter(isFileRef)
-				.map((ref) =>
-					this.storage.fileMetadata.markPendingDelete(libraryId, ref.id),
-				),
+				.map((ref) => this.storage.fileMetadata.markPendingDelete(ref.id)),
 		);
 	};
 
@@ -679,7 +672,7 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		clientKey: string,
 		info: TokenInfo,
 	) => {
-		this.sender.send(info.libraryId, clientKey, {
+		this.sender.respond(clientKey, {
 			type: 'heartbeat-response',
 		});
 	};
@@ -689,14 +682,13 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		clientKey: string,
 		info: TokenInfo,
 	) => {
-		const updated = await this.presences.set(info.libraryId, info.userId, {
+		const updated = await this.presence.set(clientKey, info.userId, {
 			presence: message.presence,
 			internal: message.internal,
 			replicaId: message.replicaId,
 			id: info.userId,
 		});
 		this.sender.broadcast(
-			info.libraryId,
 			{
 				type: 'presence-changed',
 				replicaId: message.replicaId,
@@ -707,27 +699,21 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		);
 	};
 
-	private onPresenceLost = async (
-		libraryId: string,
-		replicaId: string,
-		userId: string,
-	) => {
+	private onPresenceLost = async (replicaId: string, userId: string) => {
 		this.log('info', 'User disconnected from all replicas:', userId);
-		this.sender.broadcast(libraryId, {
+		this.sender.broadcast({
 			type: 'presence-offline',
 			replicaId,
 			userId,
 		});
-		if (Object.keys(this.presences.all(libraryId)).length === 0) {
-			this.log('info', `All users have disconnected from ${libraryId}`);
+		if (Object.keys(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) {
 				this.log('debug', 'Database not open, skipping cleanup');
 				return;
 			}
-			const pendingDelete = await this.storage.fileMetadata.getPendingDelete(
-				libraryId,
-			);
+			const pendingDelete = await this.storage.fileMetadata.getPendingDelete();
 			if (pendingDelete.length > 0) {
 				if (!this.fileStorage) {
 					throw new Error('File storage not configured, cannot delete files');
@@ -741,12 +727,11 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 					pendingDelete.map(async (fileInfo): Promise<void> => {
 						try {
 							await this.fileStorage?.delete({
-								libraryId: fileInfo.libraryId,
 								fileName: fileInfo.name,
 								id: fileInfo.fileId,
 								type: fileInfo.type,
 							});
-							this.storage.fileMetadata.delete(libraryId, fileInfo.fileId);
+							await this.storage.fileMetadata.delete(fileInfo.fileId);
 						} catch (e) {
 							this.log(
 								'error',
@@ -762,62 +747,57 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		}
 	};
 
-	destroy = async (libraryId: string) => {
-		this.log('info', 'Destroying library', libraryId);
-		this.presences.clear(libraryId);
+	destroy = async () => {
+		this.log('info', 'Destroying library');
+		this.presence.clear();
 		await Promise.all([
-			this.storage.replicas.deleteAll(libraryId),
-			this.storage.operations.deleteAll(libraryId),
-			this.storage.baselines.deleteAll(libraryId),
+			this.storage.replicas.deleteAll(),
+			this.storage.operations.deleteAll(),
+			this.storage.baselines.deleteAll(),
 		]);
-		const allFiles = await this.storage.fileMetadata.getAll(libraryId);
+		const allFiles = await this.storage.fileMetadata.getAll();
 		if (allFiles.length > 0) {
 			this.log(
 				'info',
-				`Deleting ${allFiles.length} files for library ${libraryId}`,
+				`Deleting ${allFiles.length} files`,
 				allFiles.map((f) => f.fileId).join(', '),
 			);
 			for (const fileInfo of allFiles) {
 				await this.fileStorage?.delete({
-					libraryId,
 					fileName: fileInfo.name,
 					id: fileInfo.fileId,
 					type: fileInfo.type,
 				});
 			}
-			await this.storage.fileMetadata.deleteAll(libraryId);
+			await this.storage.fileMetadata.deleteAll();
 		}
 	};
 
-	getPresence = (libraryId: string) => {
-		return this.presences.all(libraryId);
+	getPresence = () => {
+		return Promise.resolve(this.presence.all());
 	};
 
-	getInfo = async (libraryId: string): Promise<LibraryInfo | null> => {
-		const rawReplicas = await this.storage.replicas.getAll(libraryId);
-		const profiles = await Promise.all(
-			rawReplicas.map((r) => this.profiles.get(r.clientId)),
-		);
-		const replicas = rawReplicas.map((r, index) => ({
+	getInfo = async (): Promise<LibraryInfo | null> => {
+		const rawReplicas = await this.storage.replicas.getAll();
+		const replicas = rawReplicas.map((r) => ({
 			id: r.id,
+			userId: r.clientId,
 			ackedLogicalTime: r.ackedLogicalTime,
 			ackedServerOrder: r.ackedServerOrder,
 			type: r.type,
 			truant:
 				!!r.lastSeenWallClockTime &&
 				r.lastSeenWallClockTime < this.storage.replicas.truantCutoff,
-			profile: profiles[index],
+			profile: this.presence.get(r.clientId)?.profile ?? null,
 		}));
 
 		const data = {
-			id: libraryId,
+			id: this.id,
 			replicas,
-			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,
+			latestServerOrder: await this.storage.operations.getLatestServerOrder(),
+			operationsCount: await this.storage.operations.getCount(),
+			baselinesCount: await this.storage.baselines.getCount(),
+			globalAck: (await this.storage.replicas.getGlobalAck()) ?? null,
 		};
 
 		if (
@@ -831,35 +811,53 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		return data;
 	};
 
-	evictUser = async (libraryId: string, userId: string) => {
-		await this.storage.replicas.deleteAllForUser(libraryId, userId);
+	evictUser = async (userId: string) => {
+		await this.storage.replicas.deleteAllForUser(userId);
+	};
+
+	forceTruant = async (replicaId: string) => {
+		await this.storage.replicas.forceTruant(replicaId);
 	};
 
-	getDocumentSnapshot = (libraryId: string, oid: string) => {
-		return this.hydrateObject(libraryId, oid);
+	getDocumentSnapshot = (oid: string) => {
+		return this.hydrateObject(oid);
 	};
 
-	private getObjectSnapshot = async (libraryId: string, oid: string) => {
+	getFileInfo = async (fileId: string) => {
+		const rawFile = await this.hydrateFile(fileId);
+		if (rawFile) {
+			return {
+				...rawFile,
+				libraryId: this.id,
+			};
+		} else {
+			return null;
+		}
+	};
+
+	putFileInfo: (info: FileInfo) => Promise<void> = async (info) => {
+		this.log('debug', 'Storing file info', info.id, info.fileName);
+		await this.storage.fileMetadata.put(info);
+	};
+
+	private getObjectSnapshot = async (oid: string) => {
 		const [baseline, ops] = await Promise.all([
-			this.storage.baselines.get(libraryId, oid),
-			this.storage.operations.getAll(libraryId, oid),
+			this.storage.baselines.get(oid),
+			this.storage.operations.getAll(oid),
 		]);
 		const snapshot = applyOperations(baseline?.snapshot ?? undefined, ops);
 		return snapshot;
 	};
 
-	private hydrateObject = async (
-		libraryId: string,
-		oid: string,
-	): Promise<any> => {
-		const snapshot = await this.getObjectSnapshot(libraryId, oid);
+	private hydrateObject = async (oid: string): Promise<any> => {
+		const snapshot = await this.getObjectSnapshot(oid);
 		if (Array.isArray(snapshot)) {
 			return Promise.all(
 				snapshot.map(async (item: any) => {
 					if (isObjectRef(item)) {
-						return this.hydrateObject(libraryId, item.id);
+						return this.hydrateObject(item.id);
 					} else if (isFileRef(item)) {
-						return this.hydrateFile(libraryId, item.id);
+						return this.hydrateFile(item.id);
 					} else {
 						return item;
 					}
@@ -870,9 +868,9 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 			await Promise.all(
 				Object.entries(snapshot).map(async ([key, value]) => {
 					if (isObjectRef(value)) {
-						hydrated[key] = await this.hydrateObject(libraryId, value.id);
+						hydrated[key] = await this.hydrateObject(value.id);
 					} else if (isFileRef(value)) {
-						hydrated[key] = await this.hydrateFile(libraryId, value.id);
+						hydrated[key] = await this.hydrateFile(value.id);
 					}
 				}),
 			);
@@ -882,22 +880,23 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		}
 	};
 
-	private hydrateFile = async (libraryId: string, fileId: string) => {
-		const data = await this.storage.fileMetadata.get(libraryId, fileId);
+	private hydrateFile = async (
+		fileId: string,
+	): Promise<Omit<LibraryFileInfo, 'libraryId'> | null> => {
+		const data = await this.storage.fileMetadata.get(fileId);
 		if (data) {
 			const url =
-				this.fileStorage?.getUrl({
+				(await this.fileStorage?.getUrl({
 					fileName: data.name,
 					id: data.fileId,
-					libraryId,
 					type: data.type,
-				}) ?? null;
+				})) ?? null;
 
 			return {
-				url,
 				id: data.fileId,
 				name: data.name,
 				type: data.type,
+				url,
 			};
 		} else {
 			return null;