@verdant-web/server 3.3.10 → 4.0.0

package/dist/esm/{ServerLibrary.js → libraries/Library.js}

@@ -1,17 +1,10 @@
-import { EventSubscriber, ReplicaType, applyOperations, isFileRef, isObjectRef, rewriteAuthzOriginator, } from '@verdant-web/common';
-import { Presence } from './Presence.js';
-export class ServerLibrary extends EventSubscriber {
-    constructor({ storage, sender, profiles, log = () => { }, disableRebasing, fileStorage, }) {
-        super();
-        /**
-         * 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.
-         */
+import { applyOperations, isFileRef, isObjectRef, ReplicaType, rewriteAuthzOriginator, } from '@verdant-web/common';
+export class Library {
+    constructor({ storage, sender, log = () => { }, disableRebasing, fileStorage, events, id, presence, }) {
         this.validateReplicaAccess = async (replicaId, clientKey, info) => {
-            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;
@@ -22,8 +15,11 @@ export class ServerLibrary extends EventSubscriber {
             return (info.type !== ReplicaType.ReadOnlyPull &&
                 info.type !== ReplicaType.ReadOnlyRealtime);
         };
-        this.receive = async (message, clientKey, info) => {
-            await this.storage.ready;
+        this.handleMessage = async (message, clientKey, info) => {
+            if (message.type === 'heartbeat') {
+                this.handleHeartbeat(message, clientKey, info);
+                return;
+            }
             const allowed = await this.validateReplicaAccess(message.replicaId, clientKey, info);
             if (!allowed)
                 return;
@@ -37,14 +33,11 @@ export class ServerLibrary extends EventSubscriber {
                 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.type);
+                    this.log('error', 'Unknown message type', message.type);
                     break;
             }
             // a bit fragile - skipping presence-update since currently
@@ -52,17 +45,28 @@ export class ServerLibrary extends EventSubscriber {
             // 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);
             }
         };
-        this.remove = (libraryId, replicaId) => {
-            this.presences.removeReplica(libraryId, replicaId);
+        this.rebroadcastOperations = async (libraryId, clientKey, replicaId, ops, baselines) => {
+            var _a, _b;
+            if (ops.length === 0 && !(baselines === null || baselines === void 0 ? void 0 : baselines.length))
+                return;
+            this.log('info', 'Rebroadcasting', ops.length, 'operations', (_a = baselines === null || baselines === void 0 ? void 0 : baselines.length) !== null && _a !== void 0 ? _a : 0, 'baselines');
+            this.sender.broadcast({
+                type: 'op-re',
+                operations: ops,
+                baselines,
+                replicaId,
+                globalAckTimestamp: (_b = (await this.storage.replicas.getGlobalAck())) !== null && _b !== void 0 ? _b : undefined,
+            }, [clientKey]);
         };
         this.handleOperation = async (message, clientKey, info) => {
+            var _a;
             if (!message.operations.length)
                 return;
             if (!this.hasWriteAccess(info)) {
-                this.sender.send(info.libraryId, clientKey, {
+                this.sender.respond(clientKey, {
                     type: 'forbidden',
                 });
                 return;
@@ -71,20 +75,20 @@ export class ServerLibrary extends EventSubscriber {
             this.rebroadcastOperations(info.libraryId, clientKey, message.replicaId, message.operations);
             // insert patches into history
             // first, record the replica's serverOrder before insertion.
-            const replicaInfo = await this.storage.replicas.getOrCreate(info.libraryId, message.replicaId, {
+            const replicaInfo = await this.storage.replicas.getOrCreate(message.replicaId, {
                 userId: info.userId,
                 type: info.type,
             });
-            const newServerOrder = await this.storage.operations.insertAll(info.libraryId, message.replicaId, message.operations);
+            const newServerOrder = await this.storage.operations.insertAll(message.replicaId, message.operations);
             this.preemptiveUpdateServerOrder(replicaInfo.replicaInfo, newServerOrder, 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,
             });
             await this.updateHighwater(message.replicaId, message.operations[message.operations.length - 1].timestamp, info);
-            this.emit(`changes`, info, message.operations, []);
+            (_a = this.events) === null || _a === void 0 ? void 0 : _a.emit(`changes`, info, message.operations, []);
         };
         /**
          * If a replica inserts operations when it's already
@@ -94,31 +98,18 @@ export class ServerLibrary extends EventSubscriber {
         this.preemptiveUpdateServerOrder = async (replicaInfo, newServerOrder, insertedOperationsCount) => {
             if (newServerOrder - replicaInfo.ackedServerOrder ===
                 insertedOperationsCount) {
-                await this.storage.replicas.updateAckedServerOrder(replicaInfo.libraryId, replicaInfo.id, newServerOrder);
+                await this.storage.replicas.updateAckedServerOrder(replicaInfo.id, newServerOrder);
                 this.log('debug', 'Preemptively updated ackedServerOrder for', replicaInfo.id, 'to', newServerOrder);
             }
         };
-        this.rebroadcastOperations = async (libraryId, clientKey, replicaId, ops, baselines) => {
-            var _a, _b;
-            if (ops.length === 0 && !(baselines === null || baselines === void 0 ? void 0 : baselines.length))
-                return;
-            this.log('info', 'Rebroadcasting', ops.length, 'operations', (_a = baselines === null || baselines === void 0 ? void 0 : baselines.length) !== null && _a !== void 0 ? _a : 0, 'baselines');
-            this.sender.broadcast(libraryId, {
-                type: 'op-re',
-                operations: ops,
-                baselines,
-                replicaId,
-                globalAckTimestamp: (_b = (await this.storage.replicas.getGlobalAck(libraryId))) !== null && _b !== void 0 ? _b : undefined,
-            }, [clientKey]);
-        };
         this.handleSync = async (message, clientKey, info) => {
-            var _a;
+            var _a, _b;
             const replicaId = message.replicaId;
             // 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, {
+                this.sender.respond(clientKey, {
                     type: 'forbidden',
                 });
                 this.log('warn', 'sync with changes from read-only replica', replicaId);
@@ -126,22 +117,22 @@ export class ServerLibrary extends EventSubscriber {
             }
             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);
+            const { status, replicaInfo: clientReplicaInfo } = await this.storage.replicas.getOrCreate(replicaId, info);
             this.log('info', `Sync from ${replicaId} (user: ${info.userId}) [ackedServerOrder: ${clientReplicaInfo.ackedServerOrder}, status: ${status}}]`);
             // for truant replicas -- if their ackedServerOrder is up-to-date, that's fine,
             // restore them.
             let overrideTruant = false;
             if (status === 'truant') {
-                const latestServerOrder = await this.storage.operations.getLatestServerOrder(info.libraryId);
+                const latestServerOrder = await this.storage.operations.getLatestServerOrder();
                 if (clientReplicaInfo.ackedServerOrder >= latestServerOrder) {
                     overrideTruant = true;
                     this.log('debug', 'Overriding truant reset; truant replica has up-to-date server order');
                 }
             }
             // lookup operations after the last ack the client gave us
-            const ops = await this.storage.operations.getAfterServerOrder(info.libraryId, clientReplicaInfo.ackedServerOrder);
+            const ops = await this.storage.operations.getAfterServerOrder(clientReplicaInfo.ackedServerOrder);
             // new, unseen replicas should reset their existing storage
             // to that of the server when joining a library.
             // truant replicas should also reset their storage.
@@ -151,7 +142,7 @@ export class ServerLibrary extends EventSubscriber {
             // 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.
             // If there are no existing operations or baselines (and the requested
@@ -182,7 +173,7 @@ export class ServerLibrary extends EventSubscriber {
             // sync after replica has updated us with full history.
             if (isEmptyLibrary && status === 'new' && message.since !== null) {
                 this.log('info', '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,
                 });
@@ -202,11 +193,11 @@ export class ServerLibrary extends EventSubscriber {
             // 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', 'Storing', message.baselines.length, 'baselines and', message.operations.length, 'operations');
-                const newServerOrder = await this.storage.operations.insertAll(info.libraryId, replicaId, message.operations);
+                const newServerOrder = await this.storage.operations.insertAll(replicaId, message.operations);
                 this.preemptiveUpdateServerOrder(clientReplicaInfo, newServerOrder, message.operations.length);
-                await this.storage.replicas.updateAcknowledgedLogicalTime(info.libraryId, replicaId, message.timestamp);
+                await this.storage.replicas.updateAcknowledgedLogicalTime(replicaId, message.timestamp);
                 // will include the new global ack
                 this.rebroadcastOperations(info.libraryId, clientKey, message.replicaId, message.operations, 
                 // we only need to broadcast baselines if we just initialized
@@ -215,7 +206,7 @@ export class ServerLibrary extends EventSubscriber {
                 // rebasing.test.ts, for example.
                 isEmptyLibrary ? message.baselines : undefined);
                 if (message.operations.length || message.baselines.length) {
-                    this.emit(`changes`, info, message.operations, message.baselines);
+                    (_a = this.events) === null || _a === void 0 ? void 0 : _a.emit(`changes`, info, message.operations, message.baselines);
                 }
             }
             if (status === 'truant') {
@@ -229,22 +220,28 @@ export class ServerLibrary extends EventSubscriber {
                 ? this.createAckNonce(serverOrderToAck)
                 : undefined;
             // respond to client
-            this.log('info', 'Sending sync response with', ops.length, 'operations and', baselines.length, 'baselines');
+            this.log('info', 'Sending sync response with', ops.length, '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: (_a = (await this.storage.replicas.getGlobalAck(info.libraryId))) !== null && _a !== void 0 ? _a : 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: (_b = (await this.storage.replicas.getGlobalAck())) !== null && _b !== void 0 ? _b : 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;
+            }
         };
         this.createAckNonce = (serverOrder) => {
             return Buffer.from(JSON.stringify(serverOrder)).toString('base64');
@@ -252,19 +249,19 @@ export class ServerLibrary extends EventSubscriber {
         this.handleAck = async (message, clientKey, info) => {
             if (message.nonce) {
                 const decodedNonce = JSON.parse(Buffer.from(message.nonce, 'base64').toString('utf8'));
-                this.log('Ack from', message.replicaId, '(user', info.userId, ')', 'with order', decodedNonce);
+                this.log('debug', 'Ack from', message.replicaId, '(user', info.userId, ')', 'with order', decodedNonce);
                 if (typeof decodedNonce !== 'number') {
                     this.log('error', 'Invalid nonce', message.nonce);
                     return;
                 }
                 const replicaId = message.replicaId;
-                await this.storage.replicas.updateAckedServerOrder(info.libraryId, replicaId, decodedNonce);
+                await this.storage.replicas.updateAckedServerOrder(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);
+                await this.storage.replicas.acknowledgeOperation(message.replicaId, message.timestamp);
+                const globalAck = await this.storage.replicas.getGlobalAck();
                 if (globalAck) {
-                    this.sender.broadcast(info.libraryId, {
+                    this.sender.broadcast({
                         type: 'global-ack',
                         timestamp: globalAck,
                     });
@@ -272,24 +269,24 @@ export class ServerLibrary extends EventSubscriber {
             }
         };
         this.updateHighwater = async (replicaId, timestamp, info, ignoreClientKeys = []) => {
-            await this.storage.replicas.updateAcknowledgedLogicalTime(info.libraryId, replicaId, timestamp);
-            const newGlobalAck = await this.storage.replicas.getGlobalAck(info.libraryId);
+            await this.storage.replicas.updateAcknowledgedLogicalTime(replicaId, timestamp);
+            const newGlobalAck = await this.storage.replicas.getGlobalAck();
             if (newGlobalAck) {
-                this.sender.broadcast(info.libraryId, {
+                this.sender.broadcast({
                     type: 'global-ack',
                     timestamp: newGlobalAck,
                 }, ignoreClientKeys);
             }
         };
         this.pendingRebaseTimeout = null;
-        this.enqueueRebase = (libraryId) => {
+        this.enqueueRebase = () => {
             if (this.disableRebasing)
                 return;
             if (!this.pendingRebaseTimeout) {
-                setTimeout(() => this.rebase(libraryId), 0);
+                setTimeout(() => this.rebase(), 0);
             }
         };
-        this.rebase = async (libraryId) => {
+        this.rebase = async () => {
             if (this.disableRebasing)
                 return;
             this.log('debug', 'Performing rebase check');
@@ -308,9 +305,9 @@ export class ServerLibrary extends EventSubscriber {
             // 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((p) => p.replicaId);
-            const globalAck = await this.storage.replicas.getGlobalAck(libraryId, activeReplicaIds);
-            const globalServerOrder = await this.storage.replicas.getEarliestAckedServerOrder(libraryId);
+            const activeReplicaIds = Object.values(this.presence.all()).map((p) => p.replicaId);
+            const globalAck = await this.storage.replicas.getGlobalAck(activeReplicaIds);
+            const globalServerOrder = await this.storage.replicas.getEarliestAckedServerOrder();
             if (!globalAck) {
                 this.log('debug', 'No global ack, skipping rebase');
                 return;
@@ -320,7 +317,7 @@ export class ServerLibrary extends EventSubscriber {
                 return;
             }
             // 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 = {};
             // if we encounter a sequential operation in history which does
             // not meet our conditions, we must ignore subsequent operations
@@ -338,33 +335,33 @@ export class ServerLibrary extends EventSubscriber {
             }
             const deletedRefs = new Array();
             for (const [documentId, ops] of Object.entries(opsToApply)) {
-                this.log('Rebasing', documentId);
-                await this.storage.baselines.applyOperations(libraryId, documentId, ops, deletedRefs);
-                await this.storage.operations.delete(libraryId, ops);
+                this.log('debug', 'Rebasing', documentId);
+                await this.storage.baselines.applyOperations(documentId, ops, deletedRefs);
+                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,
             });
             // cleanup deleted files
             await Promise.all(deletedRefs
                 .filter(isFileRef)
-                .map((ref) => this.storage.fileMetadata.markPendingDelete(libraryId, ref.id)));
+                .map((ref) => this.storage.fileMetadata.markPendingDelete(ref.id)));
         };
         this.handleHeartbeat = (_, clientKey, info) => {
-            this.sender.send(info.libraryId, clientKey, {
+            this.sender.respond(clientKey, {
                 type: 'heartbeat-response',
             });
         };
         this.handlePresenceUpdate = async (message, clientKey, info) => {
-            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, {
+            this.sender.broadcast({
                 type: 'presence-changed',
                 replicaId: message.replicaId,
                 userInfo: updated,
@@ -372,21 +369,21 @@ export class ServerLibrary extends EventSubscriber {
             // mirror back to the replica which sent it so it has profile
             []);
         };
-        this.onPresenceLost = async (libraryId, replicaId, userId) => {
+        this.onPresenceLost = async (replicaId, userId) => {
             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');
@@ -396,12 +393,11 @@ export class ServerLibrary extends EventSubscriber {
                         var _a;
                         try {
                             await ((_a = this.fileStorage) === null || _a === void 0 ? void 0 : _a.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', 'Failed to delete file', fileInfo.fileId, ' the file will remain in a pending delete state', e);
@@ -410,52 +406,49 @@ export class ServerLibrary extends EventSubscriber {
                 }
             }
         };
-        this.destroy = async (libraryId) => {
+        this.destroy = async () => {
             var _a;
-            this.log('info', 'Destroying library', libraryId);
-            this.presences.clear(libraryId);
+            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}`, allFiles.map((f) => f.fileId).join(', '));
+                this.log('info', `Deleting ${allFiles.length} files`, allFiles.map((f) => f.fileId).join(', '));
                 for (const fileInfo of allFiles) {
                     await ((_a = this.fileStorage) === null || _a === void 0 ? void 0 : _a.delete({
-                        libraryId,
                         fileName: fileInfo.name,
                         id: fileInfo.fileId,
                         type: fileInfo.type,
                     }));
                 }
-                await this.storage.fileMetadata.deleteAll(libraryId);
+                await this.storage.fileMetadata.deleteAll();
             }
         };
-        this.getPresence = (libraryId) => {
-            return this.presences.all(libraryId);
+        this.getPresence = () => {
+            return Promise.resolve(this.presence.all());
         };
-        this.getInfo = async (libraryId) => {
+        this.getInfo = async () => {
             var _a;
-            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) => ({
+            const rawReplicas = await this.storage.replicas.getAll();
+            const replicas = rawReplicas.map((r) => ({
                 id: r.id,
                 ackedLogicalTime: r.ackedLogicalTime,
                 ackedServerOrder: r.ackedServerOrder,
                 type: r.type,
                 truant: !!r.lastSeenWallClockTime &&
                     r.lastSeenWallClockTime < this.storage.replicas.truantCutoff,
-                profile: profiles[index],
             }));
             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: (_a = (await this.storage.replicas.getGlobalAck(libraryId))) !== null && _a !== void 0 ? _a : null,
+                latestServerOrder: await this.storage.operations.getLatestServerOrder(),
+                operationsCount: await this.storage.operations.getCount(),
+                baselinesCount: await this.storage.baselines.getCount(),
+                globalAck: (_a = (await this.storage.replicas.getGlobalAck())) !== null && _a !== void 0 ? _a : null,
             };
             if (data.replicas.length === 0 &&
                 data.operationsCount === 0 &&
@@ -464,30 +457,46 @@ export class ServerLibrary extends EventSubscriber {
             }
             return data;
         };
-        this.evictUser = async (libraryId, userId) => {
-            await this.storage.replicas.deleteAllForUser(libraryId, userId);
+        this.evictUser = async (userId) => {
+            await this.storage.replicas.deleteAllForUser(userId);
+        };
+        this.forceTruant = async (replicaId) => {
+            await this.storage.replicas.forceTruant(replicaId);
         };
-        this.getDocumentSnapshot = (libraryId, oid) => {
-            return this.hydrateObject(libraryId, oid);
+        this.getDocumentSnapshot = (oid) => {
+            return this.hydrateObject(oid);
         };
-        this.getObjectSnapshot = async (libraryId, oid) => {
+        this.getFileInfo = async (fileId) => {
+            const rawFile = await this.hydrateFile(fileId);
+            if (rawFile) {
+                return Object.assign(Object.assign({}, rawFile), { libraryId: this.id });
+            }
+            else {
+                return null;
+            }
+        };
+        this.putFileInfo = async (info) => {
+            this.log('debug', 'Storing file info', info.id, info.fileName);
+            await this.storage.fileMetadata.put(info);
+        };
+        this.getObjectSnapshot = async (oid) => {
             var _a;
             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((_a = baseline === null || baseline === void 0 ? void 0 : baseline.snapshot) !== null && _a !== void 0 ? _a : undefined, ops);
             return snapshot;
         };
-        this.hydrateObject = async (libraryId, oid) => {
-            const snapshot = await this.getObjectSnapshot(libraryId, oid);
+        this.hydrateObject = async (oid) => {
+            const snapshot = await this.getObjectSnapshot(oid);
             if (Array.isArray(snapshot)) {
                 return Promise.all(snapshot.map(async (item) => {
                     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;
@@ -498,10 +507,10 @@ export class ServerLibrary extends EventSubscriber {
                 const hydrated = Object.assign({}, snapshot);
                 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);
                     }
                 }));
                 return hydrated;
@@ -510,21 +519,20 @@ export class ServerLibrary extends EventSubscriber {
                 return snapshot;
             }
         };
-        this.hydrateFile = async (libraryId, fileId) => {
+        this.hydrateFile = async (fileId) => {
             var _a, _b;
-            const data = await this.storage.fileMetadata.get(libraryId, fileId);
+            const data = await this.storage.fileMetadata.get(fileId);
             if (data) {
-                const url = (_b = (_a = this.fileStorage) === null || _a === void 0 ? void 0 : _a.getUrl({
+                const url = (_b = (await ((_a = this.fileStorage) === null || _a === void 0 ? void 0 : _a.getUrl({
                     fileName: data.name,
                     id: data.fileId,
-                    libraryId,
                     type: data.type,
-                })) !== null && _b !== void 0 ? _b : null;
+                })))) !== null && _b !== void 0 ? _b : null;
                 return {
-                    url,
                     id: data.fileId,
                     name: data.name,
                     type: data.type,
+                    url,
                 };
             }
             else {
@@ -553,14 +561,15 @@ export class ServerLibrary extends EventSubscriber {
             }
             return operations;
         };
+        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);
     }
 }
-//# sourceMappingURL=ServerLibrary.js.map
+//# sourceMappingURL=Library.js.map