@verdant-web/server 2.1.3 → 3.0.0

package/dist/esm/ServerLibrary.js

@@ -1,10 +1,7 @@
-import { applyOperations, omit, ReplicaType, isObjectRef, isFileRef, EventSubscriber, } from '@verdant-web/common';
-import { ReplicaInfos } from './Replicas.js';
-import { OperationHistory } from './OperationHistory.js';
-import { Baselines } from './Baselines.js';
+import { EventSubscriber, ReplicaType, applyOperations, isFileRef, isObjectRef, } from '@verdant-web/common';
 import { Presence } from './Presence.js';
 export class ServerLibrary extends EventSubscriber {
-    constructor({ db, sender, profiles, replicaTruancyMinutes, log = () => { }, disableRebasing, fileMetadata, fileStorage, }) {
+    constructor({ storage, sender, profiles, log = () => { }, disableRebasing, fileStorage, }) {
         super();
         this.presences = new Presence();
         /**
@@ -12,30 +9,37 @@ export class ServerLibrary extends EventSubscriber {
          * exist, a user may create it. But if it does exist, its user (clientId)
          * must match the user making the request.
          */
-        this.validateReplicaAccess = (replicaId, info) => {
-            const replica = this.replicas.get(info.libraryId, replicaId);
+        this.validateReplicaAccess = async (replicaId, clientKey, info) => {
+            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;
         };
         this.hasWriteAccess = (info) => {
             return (info.type !== ReplicaType.ReadOnlyPull &&
                 info.type !== ReplicaType.ReadOnlyRealtime);
         };
         this.receive = async (message, clientKey, info) => {
-            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);
@@ -44,12 +48,12 @@ export class ServerLibrary extends EventSubscriber {
                     this.log('Unknown message type', message.type);
                     break;
             }
-            this.replicas.updateLastSeen(info.libraryId, message.replicaId);
+            await this.storage.replicas.updateLastSeen(info.libraryId, message.replicaId);
         };
         this.remove = (libraryId, replicaId) => {
             this.presences.removeReplica(libraryId, replicaId);
         };
-        this.handleOperation = (message, clientKey, info) => {
+        this.handleOperation = async (message, clientKey, info) => {
             if (!message.operations.length)
                 return;
             if (!this.hasWriteAccess(info)) {
@@ -58,70 +62,66 @@ export class ServerLibrary extends EventSubscriber {
                 });
                 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, []);
+            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(message.replicaId, message.operations[message.operations.length - 1].timestamp, info);
+            await this.updateHighwater(message.replicaId, message.operations[message.operations.length - 1].timestamp, info);
             this.emit(`changes`, info, message.operations, []);
         };
-        this.removeExtraOperationData = (operation) => {
-            return omit(operation, ['replicaId', 'serverOrder']);
-        };
-        this.rebroadcastOperations = (libraryId, clientKey, replicaId, ops, baselines) => {
-            if (ops.length === 0 && baselines.length === 0)
+        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 and', baselines.length, 'baselines');
+            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: this.replicas.getGlobalAck(libraryId),
+                globalAckTimestamp: (_b = (await this.storage.replicas.getGlobalAck(libraryId))) !== null && _b !== void 0 ? _b : undefined,
             }, [clientKey]);
         };
-        this.handleSync = (message, clientKey, info) => {
+        this.handleSync = async (message, clientKey, info) => {
+            var _a;
             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);
+            const { status, replicaInfo: clientReplicaInfo } = await this.storage.replicas.getOrCreate(info.libraryId, replicaId, info);
             const changesSince = status === 'existing' ? clientReplicaInfo.ackedLogicalTime : null;
-            this.log(`Sync from ${replicaId} (user: ${info.userId}) [ackedLogicalTime: ${changesSince}, ackedServerOrder: ${clientReplicaInfo.ackedServerOrder}, status: ${status}}]`);
+            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(info.libraryId, clientReplicaInfo.ackedServerOrder);
+            const ops = await this.storage.operations.getAfterServerOrder(info.libraryId, 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.
             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
             // history timerange was "everything", i.e. "from null"), then this is
@@ -131,13 +131,16 @@ export class ServerLibrary extends EventSubscriber {
             // the definition of this field could be improved to be more explicit
             // 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;
             // if the local library is empty and the replica is new to us,
             // but the replica is providing a "since" timestamp, this
             // suggests the local data is incomplete or gone. we request
             // this replica should respond with a full history.
             if (isEmptyLibrary && status === 'new' && message.since !== null) {
-                this.log('Detected local data is incomplete, requesting full history from replica', replicaId);
+                this.log('info', 'Detected local data is incomplete, requesting full history from replica', replicaId);
                 this.sender.send(info.libraryId, clientKey, {
                     type: 'need-since',
                     since: null,
@@ -148,42 +151,45 @@ export class ServerLibrary extends EventSubscriber {
                 // this would mean the replica is providing a full history
                 // but the library already has data. the replica should
                 // reset to the server version
-                this.log('Detected replica', replicaId, 'is providing a full history but the library already has data. Requesting replica reset.');
+                this.log('warn', 'Detected replica', replicaId, 'is providing a full history but the library already has data. Requesting replica reset.');
                 overwriteLocalData = true;
             }
             if (overwriteLocalData) {
-                this.log('Overwriting local data for replica', replicaId, 'with', baselines.length, 'baselines and', ops.length, 'operations');
+                this.log('info', 'Overwriting local data for replica', replicaId, 'with', baselines.length, 'baselines and', ops.length, 'operations');
             }
             // only write incoming replica data to storage if
             // we are not overwriting the replica's data
             if (!overwriteLocalData) {
                 // store all incoming operations and baselines
-                this.baselines.insertAll(info.libraryId, message.baselines);
-                this.log('Storing', message.baselines.length, 'baselines and', message.operations.length, 'operations');
-                this.operations.insertAll(info.libraryId, replicaId, message.operations);
-                this.replicas.updateAcknowledged(info.libraryId, replicaId, message.timestamp);
+                await this.storage.baselines.insertAll(info.libraryId, message.baselines);
+                this.log('debug', 'Storing', message.baselines.length, 'baselines and', message.operations.length, 'operations');
+                await this.storage.operations.insertAll(info.libraryId, replicaId, message.operations);
+                await this.storage.replicas.updateAcknowledgedLogicalTime(info.libraryId, replicaId, message.timestamp);
                 // will include the new global ack
-                this.rebroadcastOperations(info.libraryId, clientKey, message.replicaId, message.operations, message.baselines);
+                this.rebroadcastOperations(info.libraryId, clientKey, message.replicaId, message.operations, 
+                // 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);
                 }
             }
             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
             const ackThisNonce = this.createAckNonce(ops);
             // respond to client
-            this.log('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');
+            // 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: (_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
@@ -198,7 +204,7 @@ export class ServerLibrary extends EventSubscriber {
                 ? Buffer.from(JSON.stringify(ops[ops.length - 1].serverOrder)).toString('base64')
                 : undefined;
         };
-        this.handleAck = (message, clientKey, info) => {
+        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);
@@ -207,11 +213,11 @@ export class ServerLibrary extends EventSubscriber {
                     return;
                 }
                 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(info.libraryId, message.replicaId, message.timestamp);
-                const globalAck = this.replicas.getGlobalAck(info.libraryId);
+                await this.storage.replicas.acknowledgeOperation(info.libraryId, message.replicaId, message.timestamp);
+                const globalAck = await this.storage.replicas.getGlobalAck(info.libraryId);
                 if (globalAck) {
                     this.sender.broadcast(info.libraryId, {
                         type: 'global-ack',
@@ -220,9 +226,9 @@ export class ServerLibrary extends EventSubscriber {
                 }
             }
         };
-        this.updateHighwater = (replicaId, timestamp, info, ignoreClientKeys = []) => {
-            this.replicas.updateAcknowledged(info.libraryId, replicaId, timestamp);
-            const newGlobalAck = this.replicas.getGlobalAck(info.libraryId);
+        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);
             if (newGlobalAck) {
                 this.sender.broadcast(info.libraryId, {
                     type: 'global-ack',
@@ -238,10 +244,10 @@ export class ServerLibrary extends EventSubscriber {
                 setTimeout(() => this.rebase(libraryId), 0);
             }
         };
-        this.rebase = (libraryId) => {
+        this.rebase = async (libraryId) => {
             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
             //    from their history stack, i.e. their oldest acked timestamp is after it.
@@ -258,18 +264,18 @@ export class ServerLibrary extends EventSubscriber {
             // 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 = this.replicas.getGlobalAck(libraryId, activeReplicaIds);
-            const globalServerOrder = this.replicas.getEarliestAckedServerOrder(libraryId);
+            const globalAck = await this.storage.replicas.getGlobalAck(libraryId, activeReplicaIds);
+            const globalServerOrder = 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(libraryId, globalServerOrder);
+            const ops = await this.storage.operations.getBeforeServerOrder(libraryId, globalServerOrder);
             const opsToApply = {};
             // if we encounter a sequential operation in history which does
             // not meet our conditions, we must ignore subsequent operations
@@ -288,8 +294,8 @@ export class ServerLibrary extends EventSubscriber {
             const deletedRefs = new Array();
             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
             this.sender.broadcast(libraryId, {
@@ -297,11 +303,9 @@ export class ServerLibrary extends EventSubscriber {
                 timestamp: globalAck,
             });
             // 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)));
         };
         this.handleHeartbeat = (_, clientKey, info) => {
             this.sender.send(info.libraryId, clientKey, {
@@ -329,25 +333,25 @@ export class ServerLibrary extends EventSubscriber {
             []);
         };
         this.onPresenceLost = async (libraryId, replicaId, userId) => {
-            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('Deleting files:', pendingDelete.map((f) => f.fileId).join(', '));
+                    this.log('info', 'Deleting files:', pendingDelete.map((f) => f.fileId).join(', '));
                     await Promise.all(pendingDelete.map(async (fileInfo) => {
                         var _a;
                         try {
@@ -357,10 +361,10 @@ export class ServerLibrary extends EventSubscriber {
                                 id: fileInfo.fileId,
                                 type: fileInfo.type,
                             }));
-                            this.files.delete(libraryId, fileInfo.fileId);
+                            this.storage.fileMetadata.delete(libraryId, fileInfo.fileId);
                         }
                         catch (e) {
-                            this.log('Failed to delete file', fileInfo.fileId, ' the file will remain in a pending delete state', e);
+                            this.log('error', 'Failed to delete file', fileInfo.fileId, ' the file will remain in a pending delete state', e);
                         }
                     }));
                 }
@@ -368,13 +372,16 @@ export class ServerLibrary extends EventSubscriber {
         };
         this.destroy = async (libraryId) => {
             var _a;
+            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(`Deleting ${allFiles.length} files for library ${libraryId}`, allFiles.map((f) => f.fileId).join(', '));
+                this.log('info', `Deleting ${allFiles.length} files for library ${libraryId}`, allFiles.map((f) => f.fileId).join(', '));
                 for (const fileInfo of allFiles) {
                     await ((_a = this.fileStorage) === null || _a === void 0 ? void 0 : _a.delete({
                         libraryId,
@@ -383,7 +390,7 @@ export class ServerLibrary extends EventSubscriber {
                         type: fileInfo.type,
                     }));
                 }
-                this.files.deleteAll(libraryId);
+                await this.storage.fileMetadata.deleteAll(libraryId);
             }
         };
         this.getPresence = (libraryId) => {
@@ -391,7 +398,7 @@ export class ServerLibrary extends EventSubscriber {
         };
         this.getInfo = async (libraryId) => {
             var _a;
-            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)));
             const replicas = rawReplicas.map((r, index) => ({
                 id: r.id,
@@ -399,16 +406,16 @@ export class ServerLibrary extends EventSubscriber {
                 ackedServerOrder: r.ackedServerOrder,
                 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: (_a = this.replicas.getGlobalAck(libraryId)) !== null && _a !== void 0 ? _a : null,
+                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,
             };
             if (data.replicas.length === 0 &&
                 data.operationsCount === 0 &&
@@ -417,23 +424,25 @@ export class ServerLibrary extends EventSubscriber {
             }
             return data;
         };
-        this.evictUser = (libraryId, userId) => {
-            this.replicas.deleteAllForUser(libraryId, userId);
+        this.evictUser = async (libraryId, userId) => {
+            await this.storage.replicas.deleteAllForUser(libraryId, userId);
         };
         this.getDocumentSnapshot = (libraryId, oid) => {
             return this.hydrateObject(libraryId, oid);
         };
-        this.getObjectSnapshot = (libraryId, oid) => {
+        this.getObjectSnapshot = async (libraryId, oid) => {
             var _a;
-            const baseline = this.baselines.get(libraryId, oid);
-            const ops = this.operations.getAllFor(libraryId, oid);
+            const [baseline, ops] = await Promise.all([
+                this.storage.baselines.get(libraryId, oid),
+                this.storage.operations.getAll(libraryId, 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 = (libraryId, oid) => {
-            const snapshot = this.getObjectSnapshot(libraryId, oid);
+        this.hydrateObject = async (libraryId, oid) => {
+            const snapshot = await this.getObjectSnapshot(libraryId, oid);
             if (Array.isArray(snapshot)) {
-                return snapshot.map((item, index) => {
+                return Promise.all(snapshot.map(async (item) => {
                     if (isObjectRef(item)) {
                         return this.hydrateObject(libraryId, item.id);
                     }
@@ -443,27 +452,27 @@ export class ServerLibrary extends EventSubscriber {
                     else {
                         return item;
                     }
-                });
+                }));
             }
             else if (snapshot && typeof snapshot === 'object') {
                 const hydrated = Object.assign({}, snapshot);
-                for (const [key, value] of Object.entries(snapshot)) {
+                await Promise.all(Object.entries(snapshot).map(async ([key, value]) => {
                     if (isObjectRef(value)) {
-                        hydrated[key] = this.hydrateObject(libraryId, value.id);
+                        hydrated[key] = await this.hydrateObject(libraryId, value.id);
                     }
                     else if (isFileRef(value)) {
-                        hydrated[key] = this.hydrateFile(libraryId, value.id);
+                        hydrated[key] = await this.hydrateFile(libraryId, value.id);
                     }
-                }
+                }));
                 return hydrated;
             }
             else {
                 return snapshot;
             }
         };
-        this.hydrateFile = (libraryId, fileId) => {
+        this.hydrateFile = async (libraryId, fileId) => {
             var _a, _b;
-            const data = this.files.get(libraryId, fileId);
+            const data = await this.storage.fileMetadata.get(libraryId, fileId);
             if (data) {
                 const url = (_b = (_a = this.fileStorage) === null || _a === void 0 ? void 0 : _a.getUrl({
                     fileName: data.name,
@@ -482,18 +491,33 @@ export class ServerLibrary extends EventSubscriber {
                 return null;
             }
         };
-        this.close = () => {
-            this.db.close();
+        // MUTATES DATA. ONLY USE WHEN RETURNING DATA TO CLIENT WHICH WILL OTHERWISE
+        // NOT BE REFERENCED.
+        this.removeBaselineExtras = (baselines) => {
+            for (const baseline of baselines) {
+                // @ts-expect-error
+                delete baseline.libraryId;
+            }
+            return baselines;
+        };
+        // MUTATES DATA. ONLY USE WHEN RETURNING DATA TO CLIENT WHICH WILL OTHERWISE
+        // NOT BE REFERENCED.
+        this.removeOperationExtras = (operations) => {
+            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;
         };
-        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);
     }