@verdant-web/server 1.8.13 → 1.8.14-next.0

package/dist/esm/OperationHistory.d.ts

@@ -1,36 +1,36 @@
-import { Operation } from '@verdant-web/common';
-import { Database } from 'better-sqlite3';
-import { OperationSpec } from './types.js';
-export declare class OperationHistory {
-    private db;
-    constructor(db: Database);
-    private hydratePatch;
-    getAllFor: (libraryId: string, oid: string) => OperationSpec[];
-    getEarliest: (libraryId: string, count: number) => OperationSpec[];
-    getAfter: (libraryId: string, timestamp?: string | null) => OperationSpec[];
-    /**
-     * Returns all operations before the given timestamp
-     * in ascending chronological order
-     */
-    getBefore: (libraryId: string, before: string) => OperationSpec[];
-    /**
-     * Returns all operations after a given server order. Useful
-     * for retrieving operations that were created after a client
-     * last synced.
-     */
-    getFromServerOrder: (libraryId: string, serverOrder: number) => OperationSpec[];
-    getLatestServerOrder: (libraryId: string) => number;
-    getCount: (libraryId: string) => number;
-    /**
-     * Adds a new operation or replaces an existing one.
-     * The server order will be set to the current max + 1
-     */
-    insert: (libraryId: string, replicaId: string, item: Operation) => import("better-sqlite3").RunResult;
-    /**
-     * Inserts all operations and updates the server
-     * order for this library
-     */
-    insertAll: (libraryId: string, replicaId: string, items: Operation[]) => Promise<void>;
-    dropAll: (libraryId: string, items: Pick<OperationSpec, 'replicaId' | 'oid' | 'timestamp'>[]) => Promise<void>;
-    deleteAll: (libraryId: string) => void;
-}
+import { Operation } from '@verdant-web/common';
+import { Database } from 'better-sqlite3';
+import { OperationSpec } from './types.js';
+export declare class OperationHistory {
+    private db;
+    constructor(db: Database);
+    private hydratePatch;
+    getAllFor: (libraryId: string, oid: string) => OperationSpec[];
+    getEarliest: (libraryId: string, count: number) => OperationSpec[];
+    getAfter: (libraryId: string, timestamp?: string | null) => OperationSpec[];
+    /**
+     * Returns all operations before the given timestamp
+     * in ascending chronological order
+     */
+    getBefore: (libraryId: string, before: string) => OperationSpec[];
+    /**
+     * Returns all operations after a given server order. Useful
+     * for retrieving operations that were created after a client
+     * last synced.
+     */
+    getFromServerOrder: (libraryId: string, serverOrder: number) => OperationSpec[];
+    getLatestServerOrder: (libraryId: string) => number;
+    getCount: (libraryId: string) => number;
+    /**
+     * Adds a new operation or replaces an existing one.
+     * The server order will be set to the current max + 1
+     */
+    insert: (libraryId: string, replicaId: string, item: Operation) => import("better-sqlite3").RunResult;
+    /**
+     * Inserts all operations and updates the server
+     * order for this library
+     */
+    insertAll: (libraryId: string, replicaId: string, items: Operation[]) => Promise<void>;
+    dropAll: (libraryId: string, items: Pick<OperationSpec, 'replicaId' | 'oid' | 'timestamp'>[]) => Promise<void>;
+    deleteAll: (libraryId: string) => void;
+}

package/dist/esm/OperationHistory.js

@@ -1,161 +1,161 @@
-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;
-};
-export class OperationHistory {
-    constructor(db) {
-        this.db = db;
-        this.hydratePatch = (_a) => {
-            var { libraryId: _, data } = _a, rest = __rest(_a, ["libraryId", "data"]);
-            return Object.assign(Object.assign({}, rest), { data: JSON.parse(data) });
-        };
-        this.getAllFor = (libraryId, oid) => {
-            return this.db
+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;
+};
+export class OperationHistory {
+    constructor(db) {
+        this.db = db;
+        this.hydratePatch = (_a) => {
+            var { libraryId: _, data } = _a, rest = __rest(_a, ["libraryId", "data"]);
+            return Object.assign(Object.assign({}, rest), { data: JSON.parse(data) });
+        };
+        this.getAllFor = (libraryId, oid) => {
+            return this.db
                 .prepare(`
       SELECT * FROM OperationHistory
       WHERE libraryId = ? AND oid = ?
       ORDER BY timestamp ASC
-    `)
-                .all(libraryId, oid)
-                .map(this.hydratePatch);
-        };
-        this.getEarliest = (libraryId, count) => {
-            return this.db
+    `)
+                .all(libraryId, oid)
+                .map(this.hydratePatch);
+        };
+        this.getEarliest = (libraryId, count) => {
+            return this.db
                 .prepare(`
       SELECT * FROM OperationHistory
       WHERE libraryId = ?
       ORDER BY timestamp ASC
       LIMIT ?
-    `)
-                .all(libraryId, count)
-                .map(this.hydratePatch);
-        };
-        this.getAfter = (libraryId, timestamp = null) => {
-            if (timestamp === null) {
-                return this.db
+    `)
+                .all(libraryId, count)
+                .map(this.hydratePatch);
+        };
+        this.getAfter = (libraryId, timestamp = null) => {
+            if (timestamp === null) {
+                return this.db
                     .prepare(`
 					SELECT * FROM OperationHistory
 					WHERE libraryId = ?
 					ORDER BY timestamp ASC
-				`)
-                    .all(libraryId)
-                    .map(this.hydratePatch);
-            }
-            return this.db
+				`)
+                    .all(libraryId)
+                    .map(this.hydratePatch);
+            }
+            return this.db
                 .prepare(`
       SELECT * FROM OperationHistory
       WHERE libraryId = ? AND timestamp > ?
       ORDER BY timestamp ASC
-    `)
-                .all(libraryId, timestamp)
-                .map(this.hydratePatch);
-        };
-        /**
-         * Returns all operations before the given timestamp
-         * in ascending chronological order
-         */
-        this.getBefore = (libraryId, before) => {
-            return this.db
+    `)
+                .all(libraryId, timestamp)
+                .map(this.hydratePatch);
+        };
+        /**
+         * Returns all operations before the given timestamp
+         * in ascending chronological order
+         */
+        this.getBefore = (libraryId, before) => {
+            return this.db
                 .prepare(`
 			SELECT * FROM OperationHistory
 			WHERE libraryId = ? AND timestamp < ?
 			ORDER BY timestamp ASC
-		`)
-                .all(libraryId, before)
-                .map(this.hydratePatch);
-        };
-        /**
-         * Returns all operations after a given server order. Useful
-         * for retrieving operations that were created after a client
-         * last synced.
-         */
-        this.getFromServerOrder = (libraryId, serverOrder) => {
-            const result = this.db
+		`)
+                .all(libraryId, before)
+                .map(this.hydratePatch);
+        };
+        /**
+         * Returns all operations after a given server order. Useful
+         * for retrieving operations that were created after a client
+         * last synced.
+         */
+        this.getFromServerOrder = (libraryId, serverOrder) => {
+            const result = this.db
                 .prepare(`
 			SELECT * FROM OperationHistory
 			WHERE libraryId = ? AND serverOrder > ?
-		`)
-                .all(libraryId, serverOrder);
-            return (result || []).map(this.hydratePatch);
-        };
-        this.getLatestServerOrder = (libraryId) => {
-            const result = this.db
+		`)
+                .all(libraryId, serverOrder);
+            return (result || []).map(this.hydratePatch);
+        };
+        this.getLatestServerOrder = (libraryId) => {
+            const result = this.db
                 .prepare(`
 			SELECT MAX(serverOrder) AS serverOrder FROM OperationHistory
 			WHERE libraryId = ?
-		`)
-                .get(libraryId);
-            return (result === null || result === void 0 ? void 0 : result.serverOrder) || 0;
-        };
-        this.getCount = (libraryId) => {
-            const result = this.db
+		`)
+                .get(libraryId);
+            return (result === null || result === void 0 ? void 0 : result.serverOrder) || 0;
+        };
+        this.getCount = (libraryId) => {
+            const result = this.db
                 .prepare(`
 			SELECT COUNT(*) AS count FROM OperationHistory
 			WHERE libraryId = ?
-		`)
-                .get(libraryId);
-            return (result === null || result === void 0 ? void 0 : result.count) || 0;
-        };
-        /**
-         * Adds a new operation or replaces an existing one.
-         * The server order will be set to the current max + 1
-         */
-        this.insert = (libraryId, replicaId, item) => {
-            return this.db
+		`)
+                .get(libraryId);
+            return (result === null || result === void 0 ? void 0 : result.count) || 0;
+        };
+        /**
+         * Adds a new operation or replaces an existing one.
+         * The server order will be set to the current max + 1
+         */
+        this.insert = (libraryId, replicaId, item) => {
+            return this.db
                 .prepare(`
       INSERT OR REPLACE INTO OperationHistory (libraryId, oid, data, timestamp, replicaId, serverOrder)
       VALUES (?, ?, ?, ?, ?, (SELECT COALESCE(MAX(serverOrder), 0) FROM OperationHistory WHERE libraryId = ?) + 1)
-    `)
-                .run(libraryId, item.oid, JSON.stringify(item.data), item.timestamp, replicaId);
-        };
-        /**
-         * Inserts all operations and updates the server
-         * order for this library
-         */
-        this.insertAll = async (libraryId, replicaId, items) => {
-            const tx = this.db.transaction(() => {
-                let orderResult = this.db
+    `)
+                .run(libraryId, item.oid, JSON.stringify(item.data), item.timestamp, replicaId);
+        };
+        /**
+         * Inserts all operations and updates the server
+         * order for this library
+         */
+        this.insertAll = async (libraryId, replicaId, items) => {
+            const tx = this.db.transaction(() => {
+                let orderResult = this.db
                     .prepare(`
 					SELECT COALESCE(MAX(serverOrder), 0) AS serverOrder FROM OperationHistory WHERE libraryId = ?
-				`)
-                    .get(libraryId);
-                let currentServerOrder = orderResult.serverOrder || 0;
+				`)
+                    .get(libraryId);
+                let currentServerOrder = orderResult.serverOrder || 0;
                 const insertStatement = this.db.prepare(`
 				INSERT OR REPLACE INTO OperationHistory (libraryId, oid, data, timestamp, replicaId, serverOrder)
 				VALUES (?, ?, ?, ?, ?, ?)
-				`);
-                for (const item of items) {
-                    insertStatement.run(libraryId, item.oid, JSON.stringify(item.data), item.timestamp, replicaId, ++currentServerOrder);
-                }
-            });
-            tx();
-        };
-        this.dropAll = async (libraryId, items) => {
+				`);
+                for (const item of items) {
+                    insertStatement.run(libraryId, item.oid, JSON.stringify(item.data), item.timestamp, replicaId, ++currentServerOrder);
+                }
+            });
+            tx();
+        };
+        this.dropAll = async (libraryId, items) => {
             const deleteStatement = this.db.prepare(`
 			DELETE FROM OperationHistory
 			WHERE libraryId = ? AND replicaId = ? AND oid = ? AND timestamp = ?
-			`);
-            this.db.transaction(() => {
-                for (const item of items) {
-                    deleteStatement.run(libraryId, item.replicaId, item.oid, item.timestamp);
-                }
-            })();
-        };
-        this.deleteAll = (libraryId) => {
-            this.db
+			`);
+            this.db.transaction(() => {
+                for (const item of items) {
+                    deleteStatement.run(libraryId, item.replicaId, item.oid, item.timestamp);
+                }
+            })();
+        };
+        this.deleteAll = (libraryId) => {
+            this.db
                 .prepare(`
 			DELETE FROM OperationHistory
 			WHERE libraryId = ?
-			`)
-                .run(libraryId);
-        };
-    }
-}
+			`)
+                .run(libraryId);
+        };
+    }
+}
 //# sourceMappingURL=OperationHistory.js.map

package/dist/esm/Presence.d.ts

@@ -1,15 +1,15 @@
-/// <reference types="node" resolution-mode="require"/>
-import { UserInfo } from '@verdant-web/common';
-import EventEmitter from 'events';
-/**
- * Stores client presence in-memory for connected
- * clients
- */
-export declare class Presence extends EventEmitter {
-    private presences;
-    private getLibrary;
-    set: (libraryId: string, userId: string, presence: UserInfo<any, any>) => void;
-    removeReplica: (libraryId: string, replicaId: string) => void;
-    all: (libraryId: string) => Record<string, UserInfo<any, any>>;
-    clear: (libraryId: string) => void;
-}
+/// <reference types="node" resolution-mode="require"/>
+import { UserInfo } from '@verdant-web/common';
+import EventEmitter from 'events';
+/**
+ * Stores client presence in-memory for connected
+ * clients
+ */
+export declare class Presence extends EventEmitter {
+    private presences;
+    private getLibrary;
+    set: (libraryId: string, userId: string, presence: UserInfo<any, any>) => void;
+    removeReplica: (libraryId: string, replicaId: string) => void;
+    all: (libraryId: string) => Record<string, UserInfo<any, any>>;
+    clear: (libraryId: string) => void;
+}

package/dist/esm/Presence.js

@@ -1,53 +1,53 @@
-import EventEmitter from 'events';
-/**
- * Stores client presence in-memory for connected
- * clients
- */
-export class Presence extends EventEmitter {
-    constructor() {
-        super(...arguments);
-        this.presences = new Map();
-        this.getLibrary = (libraryId) => {
-            let map = this.presences.get(libraryId);
-            if (!map) {
-                map = {
-                    presences: {},
-                    replicaToUser: {},
-                    userToReplica: {},
-                };
-                this.presences.set(libraryId, map);
-            }
-            return map;
-        };
-        this.set = (libraryId, userId, presence) => {
-            const lib = this.getLibrary(libraryId);
-            lib.presences[userId] = presence;
-            lib.replicaToUser[presence.replicaId] = userId;
-            lib.userToReplica[userId] = lib.userToReplica[userId] || new Set();
-            lib.userToReplica[userId].add(presence.replicaId);
-        };
-        this.removeReplica = (libraryId, replicaId) => {
-            const lib = this.getLibrary(libraryId);
-            const userId = lib.replicaToUser[replicaId];
-            if (!userId)
-                return;
-            lib.userToReplica[userId].delete(replicaId);
-            if (lib.userToReplica[userId].size === 0) {
-                delete lib.presences[userId];
-                this.emit('lost', libraryId, replicaId, userId);
-                // memory cleanup
-                if (Object.keys(lib.presences).length === 0) {
-                    this.clear(libraryId);
-                }
-            }
-        };
-        this.all = (libraryId) => {
-            var _a;
-            return ((_a = this.presences.get(libraryId)) === null || _a === void 0 ? void 0 : _a.presences) || {};
-        };
-        this.clear = (libraryId) => {
-            this.presences.delete(libraryId);
-        };
-    }
-}
+import EventEmitter from 'events';
+/**
+ * Stores client presence in-memory for connected
+ * clients
+ */
+export class Presence extends EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.presences = new Map();
+        this.getLibrary = (libraryId) => {
+            let map = this.presences.get(libraryId);
+            if (!map) {
+                map = {
+                    presences: {},
+                    replicaToUser: {},
+                    userToReplica: {},
+                };
+                this.presences.set(libraryId, map);
+            }
+            return map;
+        };
+        this.set = (libraryId, userId, presence) => {
+            const lib = this.getLibrary(libraryId);
+            lib.presences[userId] = presence;
+            lib.replicaToUser[presence.replicaId] = userId;
+            lib.userToReplica[userId] = lib.userToReplica[userId] || new Set();
+            lib.userToReplica[userId].add(presence.replicaId);
+        };
+        this.removeReplica = (libraryId, replicaId) => {
+            const lib = this.getLibrary(libraryId);
+            const userId = lib.replicaToUser[replicaId];
+            if (!userId)
+                return;
+            lib.userToReplica[userId].delete(replicaId);
+            if (lib.userToReplica[userId].size === 0) {
+                delete lib.presences[userId];
+                this.emit('lost', libraryId, replicaId, userId);
+                // memory cleanup
+                if (Object.keys(lib.presences).length === 0) {
+                    this.clear(libraryId);
+                }
+            }
+        };
+        this.all = (libraryId) => {
+            var _a;
+            return ((_a = this.presences.get(libraryId)) === null || _a === void 0 ? void 0 : _a.presences) || {};
+        };
+        this.clear = (libraryId) => {
+            this.presences.delete(libraryId);
+        };
+    }
+}
 //# sourceMappingURL=Presence.js.map

package/dist/esm/Profiles.d.ts

@@ -1,10 +1,10 @@
-export interface UserProfiles<Profile> {
-    get(userId: string): Promise<Profile>;
-}
-export declare class UserProfileLoader<Profile> {
-    private source;
-    private cache;
-    constructor(source: UserProfiles<Profile>);
-    get: (userId: string) => Promise<Profile>;
-    evict: (userId: string) => void;
-}
+export interface UserProfiles<Profile> {
+    get(userId: string): Promise<Profile>;
+}
+export declare class UserProfileLoader<Profile> {
+    private source;
+    private cache;
+    constructor(source: UserProfiles<Profile>);
+    get: (userId: string) => Promise<Profile>;
+    evict: (userId: string) => void;
+}

package/dist/esm/Profiles.js

@@ -1,16 +1,16 @@
-export class UserProfileLoader {
-    constructor(source) {
-        this.source = source;
-        this.cache = new Map();
-        this.get = async (userId) => {
-            if (!this.cache.has(userId)) {
-                this.cache.set(userId, this.source.get(userId));
-            }
-            return this.cache.get(userId);
-        };
-        this.evict = (userId) => {
-            this.cache.delete(userId);
-        };
-    }
-}
+export class UserProfileLoader {
+    constructor(source) {
+        this.source = source;
+        this.cache = new Map();
+        this.get = async (userId) => {
+            if (!this.cache.has(userId)) {
+                this.cache.set(userId, this.source.get(userId));
+            }
+            return this.cache.get(userId);
+        };
+        this.evict = (userId) => {
+            this.cache.delete(userId);
+        };
+    }
+}
 //# sourceMappingURL=Profiles.js.map

package/dist/esm/ReplicaKeepaliveTimers.d.ts

@@ -1,17 +1,17 @@
-import { EventSubscriber } from '@verdant-web/common';
-/**
- * A set of timers per-replica which are
- * refreshed whenever the replica sends
- * a message to the server. If a timer expires,
- * the replica is removed from presence. This
- * is a failsafe for socket-based replicas but
- * essential for pull-based replicas.
- */
-export declare class ReplicaKeepaliveTimers extends EventSubscriber<{
-    lost: (libraryId: string, replicaId: string) => void;
-}> {
-    private timeout;
-    private timers;
-    constructor(timeout?: number);
-    refresh: (libraryId: string, replicaId: string) => void;
-}
+import { EventSubscriber } from '@verdant-web/common';
+/**
+ * A set of timers per-replica which are
+ * refreshed whenever the replica sends
+ * a message to the server. If a timer expires,
+ * the replica is removed from presence. This
+ * is a failsafe for socket-based replicas but
+ * essential for pull-based replicas.
+ */
+export declare class ReplicaKeepaliveTimers extends EventSubscriber<{
+    lost: (libraryId: string, replicaId: string) => void;
+}> {
+    private timeout;
+    private timers;
+    constructor(timeout?: number);
+    refresh: (libraryId: string, replicaId: string) => void;
+}

package/dist/esm/ReplicaKeepaliveTimers.js

@@ -1,27 +1,27 @@
-import { EventSubscriber } from '@verdant-web/common';
-/**
- * A set of timers per-replica which are
- * refreshed whenever the replica sends
- * a message to the server. If a timer expires,
- * the replica is removed from presence. This
- * is a failsafe for socket-based replicas but
- * essential for pull-based replicas.
- */
-export class ReplicaKeepaliveTimers extends EventSubscriber {
-    constructor(timeout = 30 * 1000) {
-        super();
-        this.timeout = timeout;
-        this.timers = new Map();
-        this.refresh = (libraryId, replicaId) => {
-            const existing = this.timers.get(replicaId);
-            if (existing) {
-                clearTimeout(existing);
-            }
-            this.timers.set(replicaId, setTimeout(() => {
-                this.emit('lost', libraryId, replicaId);
-                this.timers.delete(replicaId);
-            }, this.timeout));
-        };
-    }
-}
+import { EventSubscriber } from '@verdant-web/common';
+/**
+ * A set of timers per-replica which are
+ * refreshed whenever the replica sends
+ * a message to the server. If a timer expires,
+ * the replica is removed from presence. This
+ * is a failsafe for socket-based replicas but
+ * essential for pull-based replicas.
+ */
+export class ReplicaKeepaliveTimers extends EventSubscriber {
+    constructor(timeout = 30 * 1000) {
+        super();
+        this.timeout = timeout;
+        this.timers = new Map();
+        this.refresh = (libraryId, replicaId) => {
+            const existing = this.timers.get(replicaId);
+            if (existing) {
+                clearTimeout(existing);
+            }
+            this.timers.set(replicaId, setTimeout(() => {
+                this.emit('lost', libraryId, replicaId);
+                this.timers.delete(replicaId);
+            }, this.timeout));
+        };
+    }
+}
 //# sourceMappingURL=ReplicaKeepaliveTimers.js.map