@verdant-web/server 1.7.8

package/dist/esm/Replicas.js

@@ -0,0 +1,170 @@
+export class ReplicaInfos {
+    constructor(db, replicaTruancyMinutes) {
+        this.db = db;
+        this.replicaTruancyMinutes = replicaTruancyMinutes;
+        this.get = (libraryId, replicaId) => {
+            const row = this.db
+                .prepare(`
+					SELECT * FROM ReplicaInfo
+					WHERE id = ? AND libraryId = ?
+				`)
+                .get(replicaId, libraryId);
+            if (!row) {
+                return null;
+            }
+            return {
+                id: row.id,
+                libraryId: row.libraryId,
+                clientId: row.clientId,
+                lastSeenWallClockTime: row.lastSeenWallClockTime,
+                ackedLogicalTime: row.ackedLogicalTime,
+                type: row.type,
+                ackedServerOrder: row.ackedServerOrder,
+            };
+        };
+        this.getOrCreate = (libraryId, replicaId, info) => {
+            const replicaInfo = this.db
+                .prepare(`
+			SELECT * FROM ReplicaInfo
+			WHERE id = ? AND libraryId = ?
+			`)
+                .get(replicaId, libraryId);
+            if (!replicaInfo) {
+                this.db
+                    .prepare(`
+			INSERT INTO ReplicaInfo (id, clientId, libraryId, type)
+			VALUES (?, ?, ?, ?)
+			`)
+                    .run(replicaId, info.userId, libraryId, info.type);
+                return {
+                    status: 'new',
+                    replicaInfo: {
+                        id: replicaId,
+                        clientId: info.userId,
+                        ackedLogicalTime: null,
+                        lastSeenWallClockTime: null,
+                        libraryId: libraryId,
+                        type: info.type,
+                        ackedServerOrder: 0,
+                    },
+                };
+            }
+            if (replicaInfo.type !== info.type) {
+                // type should be updated if a new token changes it
+                this.db
+                    .prepare(`
+					UPDATE ReplicaInfo
+					SET type = ?
+					WHERE id = ? AND libraryId = ?
+					`)
+                    .run(info.type, replicaId, libraryId);
+            }
+            if (replicaInfo.clientId !== info.userId) {
+                throw new Error(`Replica ${replicaId} already exists with a different user ID`);
+            }
+            if (replicaInfo.lastSeenWallClockTime &&
+                replicaInfo.lastSeenWallClockTime < this.truantCutoff) {
+                return {
+                    status: 'truant',
+                    replicaInfo,
+                };
+            }
+            return {
+                status: 'existing',
+                replicaInfo,
+            };
+        };
+        this.getAllNonTruant = (libraryId) => {
+            return this.db
+                .prepare(`
+			SELECT * FROM ReplicaInfo
+			WHERE libraryId = ? AND lastSeenWallClockTime > ?
+		`)
+                .all(libraryId, this.truantCutoff);
+        };
+        this.updateLastSeen = (libraryId, replicaId) => {
+            const clockTime = new Date().getTime();
+            return this.db
+                .prepare(`
+      UPDATE ReplicaInfo
+      SET lastSeenWallClockTime = ?
+      WHERE id = ? AND libraryId = ?
+    `)
+                .run(clockTime, replicaId, libraryId);
+        };
+        this.updateAcknowledged = (libraryId, replicaId, timestamp) => {
+            this.db
+                .prepare(`
+			UPDATE ReplicaInfo
+			SET ackedLogicalTime = ?
+			WHERE id = ? AND libraryId = ?
+		`)
+                .run(timestamp, replicaId, libraryId);
+        };
+        this.updateServerOrder = (libraryId, replicaId, serverOrder) => {
+            // only increment the server order, never set it to lower than before
+            this.db
+                .prepare(`
+			UPDATE ReplicaInfo
+			SET ackedServerOrder = MAX(ackedServerOrder, ?)
+			WHERE id = ? AND libraryId = ?
+		`)
+                .run(serverOrder, replicaId, libraryId);
+        };
+        this.acknowledgeOperation = (libraryId, replicaId, timestamp) => {
+            if (!timestamp)
+                return;
+            // get the server order from the operation with the timestamp and update the replica's server order
+            // to the max of the current server order and the server order of the operation
+            this.db
+                .prepare(`
+			UPDATE ReplicaInfo
+			SET ackedLogicalTime = ?, ackedServerOrder = MAX(ackedServerOrder, COALESCE((
+				SELECT serverOrder FROM OperationHistory
+				WHERE libraryId = ? AND timestamp = ?
+			), 0))
+			WHERE id = ? AND libraryId = ?
+			`)
+                .run(timestamp, libraryId, timestamp, replicaId, libraryId);
+        };
+        this.getGlobalAck = (libraryId, onlineReplicaIds) => {
+            const nonTruant = this.getAllNonTruant(libraryId);
+            const globalAckEligible = nonTruant.filter((replica) => replica.type < 2 || (onlineReplicaIds === null || onlineReplicaIds === void 0 ? void 0 : onlineReplicaIds.includes(replica.id)));
+            // get the earliest acked time
+            return globalAckEligible.reduce((acc, replica) => {
+                if (!replica.ackedLogicalTime) {
+                    return acc;
+                }
+                if (acc === undefined) {
+                    return replica.ackedLogicalTime;
+                }
+                return acc < replica.ackedLogicalTime ? acc : replica.ackedLogicalTime;
+            }, undefined);
+        };
+        this.delete = (libraryId, replicaId) => {
+            return this.db
+                .prepare(`
+			DELETE FROM ReplicaInfo
+			WHERE id = ? AND libraryId = ?
+		`)
+                .run(replicaId, libraryId);
+        };
+        this.deleteAll = (libraryId) => {
+            return this.db
+                .prepare(`
+			DELETE FROM ReplicaInfo
+			WHERE libraryId = ?
+		`)
+                .run(libraryId);
+        };
+        this.deleteAllForUser = (libraryId, userId) => {
+            return this.db
+                .prepare(`DELETE FROM ReplicaInfo WHERE libraryId = ? AND clientId = ?`)
+                .run(libraryId, userId);
+        };
+    }
+    get truantCutoff() {
+        return Date.now() - this.replicaTruancyMinutes * 60 * 1000;
+    }
+}
+//# sourceMappingURL=Replicas.js.map

package/dist/esm/Replicas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Replicas.js","sourceRoot":"","sources":["../../src/Replicas.ts"],"names":[],"mappings":"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"}

package/dist/esm/Server.d.ts

@@ -0,0 +1,121 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { DocumentBaseline, Operation, ServerMessage } from '@verdant-web/common';
+import EventEmitter from 'events';
+import { IncomingMessage, Server as HttpServer, ServerResponse } from 'http';
+import { UserProfiles } from './Profiles.js';
+import { MessageSender } from './MessageSender.js';
+import { TokenInfo } from './TokenVerifier.js';
+import { FileStorage } from './files/FileStorage.js';
+import { FileMetadataConfig } from './files/FileMetadata.js';
+export interface ServerOptions {
+    /**
+     * Attach to a pre-existing HTTP server. Provide this if you have another server,
+     * like an Express server, that you want to add lofi to. If provided, you don't
+     * need to call .listen()
+     */
+    httpServer?: HttpServer;
+    /**
+     * The secret value used to generate tokens from your authentication endpoint.
+     * Used to verify and decode user identity and library access on connection.
+     */
+    tokenSecret: string;
+    /**
+     * The path to your SQLite database.
+     */
+    databaseFile: string;
+    /**
+     * Optionally provide an implementation of the UserProfiles interface to look up
+     * static user profile data to use in persistence. This data is considered trusted
+     * and can be used to identify users with information like name or profile image.
+     */
+    profiles?: UserProfiles<any>;
+    /**
+     * How many minutes of inactivity before a replica is considered truant and
+     * removed from the library. Defaults to 30 days.
+     */
+    replicaTruancyMinutes?: number;
+    /**
+     * Supply a logging function to log debug messages.
+     */
+    log?: (...args: any[]) => void;
+    /**
+     * Disable history compaction. Storage usage will grow indefinitely. Not recommended.
+     */
+    disableRebasing?: boolean;
+    /**
+     * Provide a FileStorage backend to accept file uploads. Without a file backend,
+     * users will not be able to synchronize files, and all files added on peer replicas
+     * will be forever unavailable.
+     *
+     * A default, filesystem-backed FileStorage implementation is provided as an export
+     * of this library.
+     */
+    fileStorage?: FileStorage;
+    fileConfig?: FileMetadataConfig;
+}
+export interface ServerEvents {
+    error: (err: any) => void;
+    warning: (msg: string, ...args: any[]) => void;
+    changes: (info: Omit<TokenInfo, 'token'>, operations: Operation[], baselines: DocumentBaseline[]) => void;
+    request: (info: TokenInfo) => void;
+    'socket-close': (info: TokenInfo) => void;
+    'socket-connection': (info: TokenInfo) => void;
+}
+export declare interface Server {
+    on<Event extends keyof ServerEvents>(ev: Event, cb: ServerEvents[Event]): this;
+    off<Event extends keyof ServerEvents>(ev: Event, cb: ServerEvents[Event]): this;
+    emit<Event extends keyof ServerEvents>(ev: Event, ...args: Parameters<ServerEvents[Event]>): boolean;
+}
+export declare class Server extends EventEmitter implements MessageSender {
+    readonly httpServer: HttpServer;
+    private wss;
+    private fileStorage?;
+    private fileMetadata;
+    private library;
+    private clientConnections;
+    private keepalives;
+    private tokenVerifier;
+    private connectionToReplicaIdMap;
+    private log;
+    private __testMode;
+    constructor(options: ServerOptions);
+    private authorizeRequest;
+    private getRequestToken;
+    private internalServerHandleRequest;
+    handleRequest: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+    /**
+     * 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.
+     */
+    handleFileRequest: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+    broadcast: (libraryId: string, message: ServerMessage, omitKeys?: string[]) => void;
+    send: (libraryId: string, key: string, message: ServerMessage) => void;
+    private handleMessage;
+    private handleConnection;
+    listen: (handle: any, listeningListener?: (() => void) | undefined) => void;
+    close: () => Promise<void>;
+    /**
+     * 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.
+     */
+    evictLibrary: (libraryId: string) => void;
+    getLibraryPresence: (libraryId: string) => Record<string, import("@verdant-web/common").UserInfo<any, any>>;
+    /**
+     * 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.
+     */
+    evictUser: (libraryId: string, userId: string) => void;
+    /**
+     * 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.
+     */
+    getDocumentSnapshot: (libraryId: string, collection: string, documentId: string) => any;
+}

package/dist/esm/Server.js

@@ -0,0 +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);
+    }
+}
+//# sourceMappingURL=Server.js.map