@verdant-web/server 1.7.8 → 1.7.9

package/dist/esm/Server.js

@@ -1,371 +1,371 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { assert, createOid, generateId, } from '@verdant-web/common';
-import EventEmitter from 'events';
-import { Server as HttpServer } from 'http';
-import { WebSocketServer } from 'ws';
-import { UserProfileLoader } from './Profiles.js';
-import create from 'better-sqlite3';
-import { URL } from 'url';
-import { ClientConnectionManager } from './ClientConnection.js';
-import { ReplicaKeepaliveTimers } from './ReplicaKeepaliveTimers.js';
-import { TokenVerifier } from './TokenVerifier.js';
-import busboy from 'busboy';
-import { Readable } from 'stream';
-import { FileMetadata } from './files/FileMetadata.js';
-import { ServerLibrary } from './ServerLibrary.js';
-import { migrations } from './migrations.js';
-class DefaultProfiles {
-    constructor() {
-        this.get = async (userId) => {
-            return { id: userId };
-        };
-    }
-}
-export class Server extends EventEmitter {
-    constructor(options) {
-        super();
-        this.clientConnections = new ClientConnectionManager();
-        this.keepalives = new ReplicaKeepaliveTimers();
-        this.connectionToReplicaIdMap = new WeakMap();
-        this.log = () => { };
-        this.__testMode = false;
-        this.authorizeRequest = (req) => {
-            return this.tokenVerifier.verifyToken(this.getRequestToken(req));
-        };
-        this.getRequestToken = (req) => {
-            if (req.headers.authorization) {
-                const [type, token] = req.headers.authorization.split(' ');
-                if (type === 'Bearer') {
-                    return token;
-                }
-            }
-            if (req.headers['sec-websocket-protocol']) {
-                // hack: read the token from the websocket protocol header
-                const [type, token] = req.headers['sec-websocket-protocol'].split(',');
-                if (type === 'Bearer') {
-                    return token.trim();
-                }
-            }
-            assert(req.url, 'Request URL is required');
-            const url = new URL(req.url, 'http://localhost');
-            const token = url.searchParams.get('token');
-            assert(token, 'Token is required');
-            return token;
-        };
-        this.internalServerHandleRequest = (req, res) => {
-            const url = new URL(req.url || '', 'http://localhost');
-            if (url.pathname.startsWith('lofi')) {
-                if (url.pathname === 'lofi') {
-                    return this.handleRequest(req, res);
-                }
-                else if (url.pathname.startsWith('/lofi/files/')) {
-                    return this.handleFileRequest(req, res);
-                }
-            }
-            else {
-                res.writeHead(404);
-                res.end();
-            }
-        };
-        this.handleRequest = async (req, res) => {
-            var _a;
-            try {
-                if (req.method === 'POST') {
-                    const info = this.authorizeRequest(req);
-                    const key = generateId();
-                    const finish = this.clientConnections.addRequest(info.libraryId, key, req, res, info);
-                    // FIXME: extremely naive compatibility with connect-like
-                    // servers...
-                    const body = (_a = req.body) !== null && _a !== void 0 ? _a : (await new Promise((resolve, reject) => {
-                        let body = '';
-                        req.on('data', (chunk) => {
-                            body += chunk;
-                        });
-                        req.on('end', () => {
-                            resolve(JSON.parse(body));
-                        });
-                        req.on('error', (e) => {
-                            reject(e);
-                        });
-                    }));
-                    for (const message of body.messages) {
-                        await this.handleMessage(key, info, message);
-                    }
-                    // update our keepalive timers for presence management
-                    const firstMessage = body.messages[0];
-                    if (firstMessage) {
-                        this.keepalives.refresh(info.libraryId, firstMessage.replicaId);
-                    }
-                    finish();
-                    this.emit('request', info);
-                }
-            }
-            catch (e) {
-                this.emit('error', e);
-                res.writeHead(500);
-                res.end();
-            }
-        };
-        /**
-         * Handles a multipart upload of a file from a verdant client. The upload
-         * will include parameters for the file's ID, name, and type. The request
-         * must be authenticated with a token to tie it to a library.
-         */
-        this.handleFileRequest = async (req, res) => {
-            const fs = this.fileStorage;
-            if (!fs) {
-                this.emit('error', new Error('No file storage configured, but a client attempted to upload a file.'));
-                res.writeHead(500);
-                res.write('File storage is not configured');
-                res.end();
-                return;
-            }
-            // FIXME: rather than trying to support Express, I should
-            // just expose regular methods you call from whatever HTTP handler...
-            const url = new URL(req.originalUrl || req.baseUrl || req.url || '', 'http://localhost');
-            const id = url.pathname.split('/').pop();
-            if (!id || id === 'files') {
-                res.writeHead(400);
-                res.write('File ID is required to be in the URL path as the last parameter');
-                res.end();
-                return;
-            }
-            try {
-                if (req.method === 'POST') {
-                    const info = this.authorizeRequest(req);
-                    await new Promise((resolve, reject) => {
-                        const bb = busboy({ headers: req.headers });
-                        bb.on('file', (fieldName, stream, fileInfo) => {
-                            // too many 'info's....
-                            const lofiFileInfo = {
-                                id,
-                                libraryId: info.libraryId,
-                                fileName: fileInfo.filename,
-                                type: fileInfo.mimeType,
-                            };
-                            // write metadata to storage
-                            try {
-                                this.fileMetadata.put(info.libraryId, lofiFileInfo);
-                                fs.put(stream, lofiFileInfo);
-                            }
-                            catch (e) {
-                                reject(e);
-                            }
-                        });
-                        bb.on('field', (fieldName, value) => {
-                            if (fieldName === 'file') {
-                                if (this.__testMode) {
-                                    // this isn't right in the real world, but in testing it's
-                                    // the only way we get file data.
-                                    // we create a stream from the data and pass it as if it
-                                    // were a file stream
-                                    const stream = new Readable();
-                                    stream.push(value);
-                                    stream.push(null);
-                                    const fileInfo = {
-                                        filename: 'test.txt',
-                                        mimeType: 'text/plain',
-                                    };
-                                    bb.emit('file', fieldName, stream, fileInfo);
-                                }
-                                else {
-                                    throw new Error('Invalid file upload');
-                                }
-                            }
-                        });
-                        req.pipe(bb);
-                        bb.on('finish', resolve);
-                        bb.on('error', reject);
-                    });
-                    this.log('File upload complete');
-                    res.writeHead(200);
-                    res.write(JSON.stringify({ success: true }));
-                    res.end();
-                }
-                else if (req.method === 'GET') {
-                    const info = this.authorizeRequest(req);
-                    const fileInfo = this.fileMetadata.get(info.libraryId, id);
-                    if (!fileInfo) {
-                        res.writeHead(404);
-                        res.end();
-                        return;
-                    }
-                    const url = await fs.getUrl({
-                        fileName: fileInfo.name,
-                        id: fileInfo.fileId,
-                        libraryId: info.libraryId,
-                        type: fileInfo.type,
-                    });
-                    res.writeHead(200, {
-                        'Content-Type': 'application/json',
-                    });
-                    // we need to augment that data with the URL from the file backend.
-                    // and generally enforce the FileData interface here...
-                    const data = {
-                        id: fileInfo.fileId,
-                        url,
-                        remote: true,
-                        name: fileInfo.name,
-                        type: fileInfo.type,
-                    };
-                    res.write(JSON.stringify(data));
-                    res.end();
-                }
-            }
-            catch (e) {
-                this.log('Error handling file request', e);
-                this.emit('error', e);
-                res.writeHead(500);
-                res.end();
-            }
-        };
-        this.broadcast = (libraryId, message, omitKeys = []) => {
-            this.clientConnections.broadcast(libraryId, message, omitKeys);
-        };
-        this.send = (libraryId, key, message) => {
-            this.clientConnections.respond(libraryId, key, message);
-        };
-        this.handleMessage = (clientKey, info, message) => {
-            this.log('Got message from user', info.userId, ', library', info.libraryId, JSON.stringify(message));
-            return this.library.receive(message, clientKey, info);
-        };
-        this.handleConnection = (ws, req, info) => {
-            const key = generateId();
-            this.clientConnections.addSocket(info.libraryId, key, ws, info);
-            ws.on('message', async (message) => {
-                const data = JSON.parse(message.toString());
-                if (data.replicaId) {
-                    this.connectionToReplicaIdMap.set(ws, data.replicaId);
-                    this.keepalives.refresh(info.libraryId, data.replicaId);
-                }
-                await this.handleMessage(key, info, data);
-            });
-            ws.on('close', () => {
-                const replicaId = this.connectionToReplicaIdMap.get(ws);
-                if (!replicaId) {
-                    this.emit('warning', 'Unknown replica disconnected', ws);
-                    return;
-                }
-                this.library.remove(info.libraryId, replicaId);
-                this.emit('socket-close', info);
-            });
-            this.emit('socket-connection', info);
-        };
-        this.listen = (...params) => {
-            this.httpServer.listen(...params);
-        };
-        this.close = async () => {
-            await Promise.all([
-                new Promise((resolve) => {
-                    setTimeout(() => {
-                        console.warn('HTTP server close timed out');
-                        resolve();
-                    }, 5 * 1000);
-                    this.httpServer.close(() => {
-                        resolve();
-                        this.log('HTTP server closed');
-                    });
-                }),
-                new Promise((resolve) => {
-                    setTimeout(() => {
-                        console.warn('Socket server close timed out');
-                        resolve();
-                    }, 5 * 1000);
-                    this.wss.close(() => {
-                        resolve();
-                        this.log('Socket server closed');
-                    });
-                }),
-            ]);
-            this.library.close();
-        };
-        /**
-         * Completely remove a library from the server.
-         * This will remove all data associated with the library.
-         * Use it very carefully! Data will still be stored on user
-         * devices, so this is not as scary as it sounds - the next time
-         * any replica connects, it will repopulate the library. But
-         * you should still be careful.
-         */
-        this.evictLibrary = (libraryId) => {
-            // disconnect all clients
-            this.clientConnections.disconnectAll(libraryId);
-            this.library.destroy(libraryId);
-            this.log('Evicted library', libraryId);
-        };
-        this.getLibraryPresence = (libraryId) => {
-            return this.library.getPresence(libraryId);
-        };
-        /**
-         * Removes all replicas associated with a User ID from
-         * the server. Consistency algorithms will no longer wait on these
-         * replicas before confirming and squashing changes.
-         */
-        this.evictUser = (libraryId, userId) => {
-            this.library.evictUser(libraryId, userId);
-            this.log('Evicted user', userId, 'from library', libraryId);
-        };
-        /**
-         * Retrieves a snapshot of the full document contents at this time.
-         * Useful for capturing the shape of data for static usage outside
-         * of the live system.
-         */
-        this.getDocumentSnapshot = (libraryId, collection, documentId) => {
-            return this.library.getDocumentSnapshot(libraryId, createOid(collection, documentId, []));
-        };
-        this.__testMode =
-            process.env.NODE_ENV === 'test' && process.env.VITEST === 'true';
-        this.log = options.log || this.log;
-        this.tokenVerifier = new TokenVerifier({
-            secret: options.tokenSecret,
-        });
-        this.fileStorage = options.fileStorage;
-        const db = create(options.databaseFile);
-        migrations(db);
-        this.fileMetadata = new FileMetadata(db, options.fileConfig);
-        this.library = new ServerLibrary({
-            db,
-            sender: this,
-            profiles: new UserProfileLoader(options.profiles || new DefaultProfiles()),
-            log: this.log,
-            disableRebasing: options.disableRebasing,
-            fileMetadata: this.fileMetadata,
-            fileStorage: this.fileStorage,
-            replicaTruancyMinutes: options.replicaTruancyMinutes || 60 * 24 * 14,
-        });
-        this.library.subscribe('changes', (_a, operations, baselines) => {
-            var { token } = _a, info = __rest(_a, ["token"]);
-            this.emit('changes', info, operations, baselines);
-        });
-        this.wss = new WebSocketServer({
-            noServer: true,
-        });
-        this.wss.on('connection', this.handleConnection);
-        this.httpServer =
-            options.httpServer || new HttpServer(this.internalServerHandleRequest);
-        this.httpServer.on('upgrade', async (req, socket, head) => {
-            try {
-                const info = this.authorizeRequest(req);
-                this.wss.handleUpgrade(req, socket, head, (ws) => {
-                    this.wss.emit('connection', ws, req, info);
-                });
-            }
-            catch (e) {
-                this.emit('error', e);
-                socket.destroy();
-            }
-        });
-        this.keepalives.subscribe('lost', this.library.remove);
-    }
-}
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { assert, createOid, generateId, } from '@verdant-web/common';
+import EventEmitter from 'events';
+import { Server as HttpServer } from 'http';
+import { WebSocketServer } from 'ws';
+import { UserProfileLoader } from './Profiles.js';
+import create from 'better-sqlite3';
+import { URL } from 'url';
+import { ClientConnectionManager } from './ClientConnection.js';
+import { ReplicaKeepaliveTimers } from './ReplicaKeepaliveTimers.js';
+import { TokenVerifier } from './TokenVerifier.js';
+import busboy from 'busboy';
+import { Readable } from 'stream';
+import { FileMetadata } from './files/FileMetadata.js';
+import { ServerLibrary } from './ServerLibrary.js';
+import { migrations } from './migrations.js';
+class DefaultProfiles {
+    constructor() {
+        this.get = async (userId) => {
+            return { id: userId };
+        };
+    }
+}
+export class Server extends EventEmitter {
+    constructor(options) {
+        super();
+        this.clientConnections = new ClientConnectionManager();
+        this.keepalives = new ReplicaKeepaliveTimers();
+        this.connectionToReplicaIdMap = new WeakMap();
+        this.log = () => { };
+        this.__testMode = false;
+        this.authorizeRequest = (req) => {
+            return this.tokenVerifier.verifyToken(this.getRequestToken(req));
+        };
+        this.getRequestToken = (req) => {
+            if (req.headers.authorization) {
+                const [type, token] = req.headers.authorization.split(' ');
+                if (type === 'Bearer') {
+                    return token;
+                }
+            }
+            if (req.headers['sec-websocket-protocol']) {
+                // hack: read the token from the websocket protocol header
+                const [type, token] = req.headers['sec-websocket-protocol'].split(',');
+                if (type === 'Bearer') {
+                    return token.trim();
+                }
+            }
+            assert(req.url, 'Request URL is required');
+            const url = new URL(req.url, 'http://localhost');
+            const token = url.searchParams.get('token');
+            assert(token, 'Token is required');
+            return token;
+        };
+        this.internalServerHandleRequest = (req, res) => {
+            const url = new URL(req.url || '', 'http://localhost');
+            if (url.pathname.startsWith('lofi')) {
+                if (url.pathname === 'lofi') {
+                    return this.handleRequest(req, res);
+                }
+                else if (url.pathname.startsWith('/lofi/files/')) {
+                    return this.handleFileRequest(req, res);
+                }
+            }
+            else {
+                res.writeHead(404);
+                res.end();
+            }
+        };
+        this.handleRequest = async (req, res) => {
+            var _a;
+            try {
+                if (req.method === 'POST') {
+                    const info = this.authorizeRequest(req);
+                    const key = generateId();
+                    const finish = this.clientConnections.addRequest(info.libraryId, key, req, res, info);
+                    // FIXME: extremely naive compatibility with connect-like
+                    // servers...
+                    const body = (_a = req.body) !== null && _a !== void 0 ? _a : (await new Promise((resolve, reject) => {
+                        let body = '';
+                        req.on('data', (chunk) => {
+                            body += chunk;
+                        });
+                        req.on('end', () => {
+                            resolve(JSON.parse(body));
+                        });
+                        req.on('error', (e) => {
+                            reject(e);
+                        });
+                    }));
+                    for (const message of body.messages) {
+                        await this.handleMessage(key, info, message);
+                    }
+                    // update our keepalive timers for presence management
+                    const firstMessage = body.messages[0];
+                    if (firstMessage) {
+                        this.keepalives.refresh(info.libraryId, firstMessage.replicaId);
+                    }
+                    finish();
+                    this.emit('request', info);
+                }
+            }
+            catch (e) {
+                this.emit('error', e);
+                res.writeHead(500);
+                res.end();
+            }
+        };
+        /**
+         * Handles a multipart upload of a file from a verdant client. The upload
+         * will include parameters for the file's ID, name, and type. The request
+         * must be authenticated with a token to tie it to a library.
+         */
+        this.handleFileRequest = async (req, res) => {
+            const fs = this.fileStorage;
+            if (!fs) {
+                this.emit('error', new Error('No file storage configured, but a client attempted to upload a file.'));
+                res.writeHead(500);
+                res.write('File storage is not configured');
+                res.end();
+                return;
+            }
+            // FIXME: rather than trying to support Express, I should
+            // just expose regular methods you call from whatever HTTP handler...
+            const url = new URL(req.originalUrl || req.baseUrl || req.url || '', 'http://localhost');
+            const id = url.pathname.split('/').pop();
+            if (!id || id === 'files') {
+                res.writeHead(400);
+                res.write('File ID is required to be in the URL path as the last parameter');
+                res.end();
+                return;
+            }
+            try {
+                if (req.method === 'POST') {
+                    const info = this.authorizeRequest(req);
+                    await new Promise((resolve, reject) => {
+                        const bb = busboy({ headers: req.headers });
+                        bb.on('file', (fieldName, stream, fileInfo) => {
+                            // too many 'info's....
+                            const lofiFileInfo = {
+                                id,
+                                libraryId: info.libraryId,
+                                fileName: fileInfo.filename,
+                                type: fileInfo.mimeType,
+                            };
+                            // write metadata to storage
+                            try {
+                                this.fileMetadata.put(info.libraryId, lofiFileInfo);
+                                fs.put(stream, lofiFileInfo);
+                            }
+                            catch (e) {
+                                reject(e);
+                            }
+                        });
+                        bb.on('field', (fieldName, value) => {
+                            if (fieldName === 'file') {
+                                if (this.__testMode) {
+                                    // this isn't right in the real world, but in testing it's
+                                    // the only way we get file data.
+                                    // we create a stream from the data and pass it as if it
+                                    // were a file stream
+                                    const stream = new Readable();
+                                    stream.push(value);
+                                    stream.push(null);
+                                    const fileInfo = {
+                                        filename: 'test.txt',
+                                        mimeType: 'text/plain',
+                                    };
+                                    bb.emit('file', fieldName, stream, fileInfo);
+                                }
+                                else {
+                                    throw new Error('Invalid file upload');
+                                }
+                            }
+                        });
+                        req.pipe(bb);
+                        bb.on('finish', resolve);
+                        bb.on('error', reject);
+                    });
+                    this.log('File upload complete');
+                    res.writeHead(200);
+                    res.write(JSON.stringify({ success: true }));
+                    res.end();
+                }
+                else if (req.method === 'GET') {
+                    const info = this.authorizeRequest(req);
+                    const fileInfo = this.fileMetadata.get(info.libraryId, id);
+                    if (!fileInfo) {
+                        res.writeHead(404);
+                        res.end();
+                        return;
+                    }
+                    const url = await fs.getUrl({
+                        fileName: fileInfo.name,
+                        id: fileInfo.fileId,
+                        libraryId: info.libraryId,
+                        type: fileInfo.type,
+                    });
+                    res.writeHead(200, {
+                        'Content-Type': 'application/json',
+                    });
+                    // we need to augment that data with the URL from the file backend.
+                    // and generally enforce the FileData interface here...
+                    const data = {
+                        id: fileInfo.fileId,
+                        url,
+                        remote: true,
+                        name: fileInfo.name,
+                        type: fileInfo.type,
+                    };
+                    res.write(JSON.stringify(data));
+                    res.end();
+                }
+            }
+            catch (e) {
+                this.log('Error handling file request', e);
+                this.emit('error', e);
+                res.writeHead(500);
+                res.end();
+            }
+        };
+        this.broadcast = (libraryId, message, omitKeys = []) => {
+            this.clientConnections.broadcast(libraryId, message, omitKeys);
+        };
+        this.send = (libraryId, key, message) => {
+            this.clientConnections.respond(libraryId, key, message);
+        };
+        this.handleMessage = (clientKey, info, message) => {
+            this.log('Got message from user', info.userId, ', library', info.libraryId, JSON.stringify(message));
+            return this.library.receive(message, clientKey, info);
+        };
+        this.handleConnection = (ws, req, info) => {
+            const key = generateId();
+            this.clientConnections.addSocket(info.libraryId, key, ws, info);
+            ws.on('message', async (message) => {
+                const data = JSON.parse(message.toString());
+                if (data.replicaId) {
+                    this.connectionToReplicaIdMap.set(ws, data.replicaId);
+                    this.keepalives.refresh(info.libraryId, data.replicaId);
+                }
+                await this.handleMessage(key, info, data);
+            });
+            ws.on('close', () => {
+                const replicaId = this.connectionToReplicaIdMap.get(ws);
+                if (!replicaId) {
+                    this.emit('warning', 'Unknown replica disconnected', ws);
+                    return;
+                }
+                this.library.remove(info.libraryId, replicaId);
+                this.emit('socket-close', info);
+            });
+            this.emit('socket-connection', info);
+        };
+        this.listen = (...params) => {
+            this.httpServer.listen(...params);
+        };
+        this.close = async () => {
+            await Promise.all([
+                new Promise((resolve) => {
+                    setTimeout(() => {
+                        console.warn('HTTP server close timed out');
+                        resolve();
+                    }, 5 * 1000);
+                    this.httpServer.close(() => {
+                        resolve();
+                        this.log('HTTP server closed');
+                    });
+                }),
+                new Promise((resolve) => {
+                    setTimeout(() => {
+                        console.warn('Socket server close timed out');
+                        resolve();
+                    }, 5 * 1000);
+                    this.wss.close(() => {
+                        resolve();
+                        this.log('Socket server closed');
+                    });
+                }),
+            ]);
+            this.library.close();
+        };
+        /**
+         * Completely remove a library from the server.
+         * This will remove all data associated with the library.
+         * Use it very carefully! Data will still be stored on user
+         * devices, so this is not as scary as it sounds - the next time
+         * any replica connects, it will repopulate the library. But
+         * you should still be careful.
+         */
+        this.evictLibrary = (libraryId) => {
+            // disconnect all clients
+            this.clientConnections.disconnectAll(libraryId);
+            this.library.destroy(libraryId);
+            this.log('Evicted library', libraryId);
+        };
+        this.getLibraryPresence = (libraryId) => {
+            return this.library.getPresence(libraryId);
+        };
+        /**
+         * Removes all replicas associated with a User ID from
+         * the server. Consistency algorithms will no longer wait on these
+         * replicas before confirming and squashing changes.
+         */
+        this.evictUser = (libraryId, userId) => {
+            this.library.evictUser(libraryId, userId);
+            this.log('Evicted user', userId, 'from library', libraryId);
+        };
+        /**
+         * Retrieves a snapshot of the full document contents at this time.
+         * Useful for capturing the shape of data for static usage outside
+         * of the live system.
+         */
+        this.getDocumentSnapshot = (libraryId, collection, documentId) => {
+            return this.library.getDocumentSnapshot(libraryId, createOid(collection, documentId, []));
+        };
+        this.__testMode =
+            process.env.NODE_ENV === 'test' && process.env.VITEST === 'true';
+        this.log = options.log || this.log;
+        this.tokenVerifier = new TokenVerifier({
+            secret: options.tokenSecret,
+        });
+        this.fileStorage = options.fileStorage;
+        const db = create(options.databaseFile);
+        migrations(db);
+        this.fileMetadata = new FileMetadata(db, options.fileConfig);
+        this.library = new ServerLibrary({
+            db,
+            sender: this,
+            profiles: new UserProfileLoader(options.profiles || new DefaultProfiles()),
+            log: this.log,
+            disableRebasing: options.disableRebasing,
+            fileMetadata: this.fileMetadata,
+            fileStorage: this.fileStorage,
+            replicaTruancyMinutes: options.replicaTruancyMinutes || 60 * 24 * 14,
+        });
+        this.library.subscribe('changes', (_a, operations, baselines) => {
+            var { token } = _a, info = __rest(_a, ["token"]);
+            this.emit('changes', info, operations, baselines);
+        });
+        this.wss = new WebSocketServer({
+            noServer: true,
+        });
+        this.wss.on('connection', this.handleConnection);
+        this.httpServer =
+            options.httpServer || new HttpServer(this.internalServerHandleRequest);
+        this.httpServer.on('upgrade', async (req, socket, head) => {
+            try {
+                const info = this.authorizeRequest(req);
+                this.wss.handleUpgrade(req, socket, head, (ws) => {
+                    this.wss.emit('connection', ws, req, info);
+                });
+            }
+            catch (e) {
+                this.emit('error', e);
+                socket.destroy();
+            }
+        });
+        this.keepalives.subscribe('lost', this.library.remove);
+    }
+}
 //# sourceMappingURL=Server.js.map