polfan-server-js-client 0.3.3 → 0.4.0

package/src/types/src/schemes/User.ts

@@ -1,9 +1,25 @@
 export type UserTags = 'bot' | 'temp' | string;
 
+/**
+ * Availability of a user, aggregated over all of their sessions.
+ *
+ * - `Offline` - no session is connected and none can be reached asynchronously.
+ * - `Online` - at least one session holds a live connection.
+ * - `OnlineAsync` - no live connection, but a push-registered device was active
+ *   recently, so a message will still reach the user.
+ */
+export enum UserStatus {
+    Offline = 0,
+    Online = 1,
+    OnlineAsync = 2,
+}
+
 export interface User {
     id: string;
     nick: string;
     avatar: string;
     tags: UserTags[];
+    status: UserStatus;
+    /** @deprecated Use {@link status}. Kept for clients older than the numeric status. */
     online: boolean;
-}
+}

package/src/types/src/schemes/UserData.ts

@@ -2,4 +2,9 @@ export type PrivateMessagePolicy = 'None' | 'Mutual' | 'All';
 
 export interface UserData {
     privateMessagePolicy: PrivateMessagePolicy;
+    /**
+     * Whether others may see that the user is reachable on a push-registered
+     * device while disconnected. When false the user simply reads as offline.
+     */
+    showAsyncPresence: boolean;
 }

package/src/types/src/schemes/commands/SetSessionData.ts

@@ -1,10 +1,19 @@
+import {SessionPlatform} from "../SessionData";
+
 export interface SessionPush {
     token?: string;
-    platform?: 'ios' | 'android' | 'web';
     active?: boolean;
+    /**
+     * @deprecated The platform describes the session, not its push registration.
+     * Use {@link SetSessionData.platform} (or the `platform` connection query
+     * parameter). Still accepted by the server, but the top-level field wins.
+     */
+    platform?: SessionPlatform;
 }
 
 export interface SetSessionData {
     clientFocused?: boolean;
     push?: SessionPush;
-}
+    /** Client platform of this session; null leaves the stored value unchanged. */
+    platform?: SessionPlatform;
+}

package/src/types/src/schemes/commands/SetUserData.ts

@@ -2,4 +2,5 @@ import {PrivateMessagePolicy} from "../UserData";
 
 export interface SetUserData {
     privateMessagePolicy?: PrivateMessagePolicy;
+    showAsyncPresence?: boolean;
 }

package/tests/async-utils.test.ts

@@ -1,30 +1,30 @@
-import {PromiseRegistry} from "../src/state-tracker/AsyncUtils";
-
-test('promise registry - limit the calling of async process', async () => {
-    const pr = new PromiseRegistry();
-    let generationCount = 0;
-
-    async function generateResult() {
-        return ++generationCount;
-    }
-
-    async function getResult() {
-        const resultKey = 'test';
-
-        if (pr.notExist('test')) {
-            pr.registerByFunction(generateResult, resultKey);
-        }
-
-        await pr.get(resultKey);
-        return generationCount;
-    }
-
-    const call1 = await getResult();
-    expect(call1).toBe(1);
-    const call2 = await getResult();
-    expect(call2).toBe(1);
-    const call3 = await getResult();
-    expect(call3).toBe(1);
-
-    expect(generationCount).toBe(1);
+import {PromiseRegistry} from "../src/state-tracker/AsyncUtils";
+
+test('promise registry - limit the calling of async process', async () => {
+    const pr = new PromiseRegistry();
+    let generationCount = 0;
+
+    async function generateResult() {
+        return ++generationCount;
+    }
+
+    async function getResult() {
+        const resultKey = 'test';
+
+        if (pr.notExist('test')) {
+            pr.registerByFunction(generateResult, resultKey);
+        }
+
+        await pr.get(resultKey);
+        return generationCount;
+    }
+
+    const call1 = await getResult();
+    expect(call1).toBe(1);
+    const call2 = await getResult();
+    expect(call2).toBe(1);
+    const call3 = await getResult();
+    expect(call3).toBe(1);
+
+    expect(generationCount).toBe(1);
 });

package/tests/history-window.test.ts

@@ -209,137 +209,6 @@ test('history window - reset to latest', async () => {
     [7,8,9].forEach(id => expect(window.items.map(item => item.id)).toContain(id));
 });
 
-test('history window - resync to latest merges the new page into loaded items', async () => {
-    const window = new TestableHistoryWindow();
-    window.limit = 10;
-    window.fetchLimit = 3;
-
-    await window.resetToLatest(); // [7,8,9]
-    await window.fetchPrevious(); // [4,5,6,7,8,9]
-
-    await window.resyncToLatest(); // fetched [7,8,9] overlaps -> nothing is lost
-
-    expect(window.state).toEqual(WindowState.LATEST);
-    expect(window.items.map(item => item.id)).toEqual([4, 5, 6, 7, 8, 9]);
-});
-
-test('history window - resync to latest trims the merged items to the limit', async () => {
-    const window = new TestableHistoryWindow();
-    window.limit = 4;
-    window.fetchLimit = 3;
-
-    await window.resetToLatest(); // [7,8,9]
-    await window.fetchPrevious(); // [4,5,6,7] (trimmed to the limit)
-
-    // [4,5,6,7] merged with the page [7,8,9] -> [4,5,6,7,8,9], trimmed again.
-    await window.resyncToLatest();
-
-    expect(window.state).toEqual(WindowState.LATEST);
-    expect(window.items.map(item => item.id)).toEqual([6, 7, 8, 9]);
-});
-
-test('history window - resync to latest marks the gap instead of dropping items', async () => {
-    const window = new TestableHistoryWindow();
-    window.limit = 10;
-    window.fetchLimit = 3;
-
-    await window.jumpTo('1'); // [0,1,2]
-
-    expect(window.gaps).toEqual([]);
-
-    // A full page ([7,8,9]) that does not reach the newest loaded item (2):
-    // items 3..6 were never fetched, so the seam in front of 7 is marked.
-    await window.resyncToLatest();
-
-    expect(window.state).toEqual(WindowState.LATEST);
-    expect(window.items.map(item => item.id)).toEqual([0, 1, 2, 7, 8, 9]);
-    expect(window.gaps).toEqual([7]);
-});
-
-test('history window - gap marker disappears with the item it points at', async () => {
-    const window = new TestableHistoryWindow();
-    window.limit = 10;
-    window.fetchLimit = 3;
-
-    await window.jumpTo('1'); // [0,1,2]
-    await window.resyncToLatest(); // [0,1,2] | [7,8,9]
-
-    expect(window.gaps).toEqual([7]);
-
-    window.delete(7);
-
-    expect(window.gaps).toEqual([]);
-});
-
-test('history window - gap marker is closed by fetching what is before it', async () => {
-    const window = new TestableHistoryWindow();
-    window.limit = 10;
-    window.fetchLimit = 3;
-
-    await window.jumpTo('1'); // [0,1,2]
-    await window.resyncToLatest(); // [0,1,2] | [7,8,9]
-    window.delete(0, 1, 2); // the items above the gap are gone, 7 is the top one
-
-    expect(window.gaps).toEqual([7]);
-
-    // Whatever comes back was fetched as the direct predecessor of 7, so the
-    // history is continuous again.
-    await window.fetchPrevious(); // [4,5,6,7,8,9]
-
-    expect(window.items.map(item => item.id)).toEqual([4, 5, 6, 7, 8, 9]);
-    expect(window.gaps).toEqual([]);
-});
-
-test('history window - gap markers are cleared when the whole window is replaced', async () => {
-    const window = new TestableHistoryWindow();
-    window.limit = 10;
-    window.fetchLimit = 3;
-
-    await window.jumpTo('1'); // [0,1,2]
-    await window.resyncToLatest(); // [0,1,2] | [7,8,9]
-
-    expect(window.gaps).toEqual([7]);
-
-    await window.resetToLatest(true); // [7,8,9] - a continuous window again
-
-    expect(window.items.map(item => item.id)).toEqual([7, 8, 9]);
-    expect(window.gaps).toEqual([]);
-});
-
-test('history window - gap marker is forgotten when trimmed out of the window', async () => {
-    const window = new TestableHistoryWindow();
-    window.limit = 10;
-    window.fetchLimit = 3;
-
-    await window.jumpTo('1'); // [0,1,2]
-    await window.resyncToLatest(); // [0,1,2] | [7,8,9]
-
-    expect(window.gaps).toEqual([7]);
-
-    // The window shrinks and the trimming pushes item 7 (and everything above
-    // it) out, so the marker has nothing left to point at.
-    window.limit = 2;
-    await window.resyncToLatest();
-
-    expect(window.items.map(item => item.id)).toEqual([8, 9]);
-    expect(window.gaps).toEqual([]);
-});
-
-test('history window - resync to latest keeps loaded items when the page is not full', async () => {
-    const window = new TestableHistoryWindow();
-    window.limit = 10;
-    window.fetchLimit = 5; // The fetch returns 3 items only - all there is.
-
-    await window.jumpTo('1'); // [0,1,2,3]
-
-    // Nothing is missing in between: the page is everything the remote side has,
-    // so the loaded items are kept even though the page does not reach them.
-    await window.resyncToLatest();
-
-    expect(window.state).toEqual(WindowState.LATEST);
-    expect(window.items.map(item => item.id)).toEqual([0, 1, 2, 3, 7, 8, 9]);
-});
-
 test('history window - jump to message', async () => {
     const window = new TestableHistoryWindow();
     window.limit = 5;

package/tests/space-roles.test.ts

@@ -1,43 +1,43 @@
-import {IndexedObjectCollection} from "../src";
-import {Role} from "pserv-ts-types";
-import {reorderRolesOnPriorityUpdate} from "../src/state-tracker/functions";
-
-const createCollection = () => new IndexedObjectCollection<Role>(
-    role => role.id,
-    [
-        {id: 'id1', name: 'everyone', priority: 0, color: '#ff0000'},
-        {id: 'id2', name: 'roleA', priority: 1, color: '#ff0000'},
-        {id: 'id3', name: 'roleB', priority: 2, color: '#ff0000'},
-        {id: 'id4', name: 'roleC', priority: 3, color: '#ff0000'},
-        {id: 'id5', name: 'roleD', priority: 4, color: '#ff0000'},
-    ],
-);
-
-test('roles reorder - increase', () => {
-    const collection = createCollection();
-    const oldRole = collection.get('id2');
-    const newRole: Role = {...oldRole, priority: 4};
-    const result = reorderRolesOnPriorityUpdate(collection.items, oldRole, newRole);
-    collection.set(newRole, ...result);
-
-    //expect(result.length).toBe(3);
-    expect(collection.get('id1').priority).toBe(0);
-    expect(collection.get('id2').priority).toBe(4);
-    expect(collection.get('id3').priority).toBe(1);
-    expect(collection.get('id4').priority).toBe(2);
-    expect(collection.get('id5').priority).toBe(3);
-});
-
-test('roles reorder - decrease', () => {
-    const collection = createCollection();
-    const oldRole = collection.get('id5');
-    const newRole: Role = {...oldRole, priority: 0};
-    const result = reorderRolesOnPriorityUpdate(collection.items, oldRole, newRole);
-    collection.set(newRole, ...result);
-
-    expect(collection.get('id1').priority).toBe(1);
-    expect(collection.get('id2').priority).toBe(2);
-    expect(collection.get('id3').priority).toBe(3);
-    expect(collection.get('id4').priority).toBe(4);
-    expect(collection.get('id5').priority).toBe(0);
+import {IndexedObjectCollection} from "../src";
+import {Role} from "pserv-ts-types";
+import {reorderRolesOnPriorityUpdate} from "../src/state-tracker/functions";
+
+const createCollection = () => new IndexedObjectCollection<Role>(
+    role => role.id,
+    [
+        {id: 'id1', name: 'everyone', priority: 0, color: '#ff0000'},
+        {id: 'id2', name: 'roleA', priority: 1, color: '#ff0000'},
+        {id: 'id3', name: 'roleB', priority: 2, color: '#ff0000'},
+        {id: 'id4', name: 'roleC', priority: 3, color: '#ff0000'},
+        {id: 'id5', name: 'roleD', priority: 4, color: '#ff0000'},
+    ],
+);
+
+test('roles reorder - increase', () => {
+    const collection = createCollection();
+    const oldRole = collection.get('id2');
+    const newRole: Role = {...oldRole, priority: 4};
+    const result = reorderRolesOnPriorityUpdate(collection.items, oldRole, newRole);
+    collection.set(newRole, ...result);
+
+    //expect(result.length).toBe(3);
+    expect(collection.get('id1').priority).toBe(0);
+    expect(collection.get('id2').priority).toBe(4);
+    expect(collection.get('id3').priority).toBe(1);
+    expect(collection.get('id4').priority).toBe(2);
+    expect(collection.get('id5').priority).toBe(3);
+});
+
+test('roles reorder - decrease', () => {
+    const collection = createCollection();
+    const oldRole = collection.get('id5');
+    const newRole: Role = {...oldRole, priority: 0};
+    const result = reorderRolesOnPriorityUpdate(collection.items, oldRole, newRole);
+    collection.set(newRole, ...result);
+
+    expect(collection.get('id1').priority).toBe(1);
+    expect(collection.get('id2').priority).toBe(2);
+    expect(collection.get('id3').priority).toBe(3);
+    expect(collection.get('id4').priority).toBe(4);
+    expect(collection.get('id5').priority).toBe(0);
 });

package/tests/state-reconnect.test.ts

@@ -210,266 +210,6 @@ describe('reconnect - MessagesManager', () => {
     });
 });
 
-describe('reconnect - time limited (MaxAge) room history', () => {
-    const HOUR = 60 * 60 * 1000;
-
-    const message = (id: string, ageInHours: number): any => ({
-        id,
-        type: 'Text',
-        content: '',
-        createdAt: new Date(Date.now() - ageInHours * HOUR).toISOString(),
-        location: { roomId: 'M', topicId: 'topic-M' },
-        author: { user: { id: 'other' } },
-        topicRef: null,
-        attachments: null,
-    });
-
-    /**
-     * Serves GetMessages from a mutable server-side message list, the way the
-     * real server does: the latest page is the newest slice of it.
-     */
-    const serveMessages = (client: FakeClient, store: any[]): void => {
-        client.respondTo('GetMessages', (data: any) => {
-            const limit = data.limit ?? 50;
-
-            if (data.before) {
-                const index = store.findIndex(m => m.id === data.before);
-                return { messages: store.slice(Math.max(0, index - limit), index) };
-            }
-
-            return { messages: store.slice(-limit) };
-        });
-    };
-
-    const maxAgeRoom = (store: any[], maxAge: number = 24 * 60 * 60): any => createRoom('M', {
-        history: { mode: 'MaxAge', maxAge },
-        defaultTopic: {
-            id: 'topic-M',
-            messageCount: store.length,
-            lastMessage: store[store.length - 1] ?? null,
-        },
-    });
-
-    /**
-     * Room M with a window pulled to LATEST and holding `m1..m5` (m1..m2 loaded
-     * by traversing back), i.e. more history than a single page.
-     */
-    const openWindowWithHistory = async (store: any[]) => {
-        const { client, tracker } = createTracker();
-        serveMessages(client, store);
-
-        emitSession(client, [maxAgeRoom(store)]);
-
-        const history = await tracker.rooms.messages.getRoomHistory('M');
-        const window = await history.getMessagesWindow('topic-M');
-        window.fetchLimit = 3;
-
-        await window.resetToLatest(); // [m3, m4, m5]
-        await window.fetchPrevious(); // [m1, m2, m3, m4, m5]
-
-        expect(window.state).toBe(WindowState.LATEST);
-        expect(window.items.map((m: any) => m.id)).toEqual(['m1', 'm2', 'm3', 'm4', 'm5']);
-
-        client.sent.length = 0;
-
-        return { client, tracker, history, window };
-    };
-
-    test('loads the missed messages and keeps the history that fits in the window', async () => {
-        const store = [
-            message('m1', 5), message('m2', 4), message('m3', 3),
-            message('m4', 2), message('m5', 1),
-        ];
-        const { client, tracker, history, window } = await openWindowWithHistory(store);
-
-        // Two messages arrived while the connection was down.
-        store.push(message('m6', 0), message('m7', 0));
-
-        emitSession(client, [maxAgeRoom(store)]);
-        await flush();
-
-        expect(await tracker.rooms.messages.getRoomHistory('M')).toBe(history);
-        expect(await history.getMessagesWindow('topic-M')).toBe(window);
-        // One request only - the new messages come with the latest page.
-        expect(client.countSent('GetMessages')).toBe(1);
-        expect(window.state).toBe(WindowState.LATEST);
-        expect(window.items.map((m: any) => m.id))
-            .toEqual(['m1', 'm2', 'm3', 'm4', 'm5', 'm6', 'm7']);
-    });
-
-    test('keeps the loaded messages older than maxAge - retention is server side only', async () => {
-        const store = [
-            message('m1', 30), message('m2', 26), message('m3', 3),
-            message('m4', 2), message('m5', 1),
-        ];
-        const { client, window } = await openWindowWithHistory(store);
-
-        // m1 and m2 are older than the room maxAge (24h), so the server stops
-        // serving them to keep them away from users who join later. The user who
-        // was there when they were written keeps them in their window.
-        store.splice(0, 2);
-        store.push(message('m6', 0));
-
-        emitSession(client, [maxAgeRoom(store)]);
-        await flush();
-
-        expect(window.items.map((m: any) => m.id))
-            .toEqual(['m1', 'm2', 'm3', 'm4', 'm5', 'm6']);
-    });
-
-    test('drops the oldest loaded messages only when the window size limit is hit', async () => {
-        const store = [
-            message('m1', 5), message('m2', 4), message('m3', 3),
-            message('m4', 2), message('m5', 1),
-        ];
-        const { client, window } = await openWindowWithHistory(store);
-
-        window.limit = 4;
-        store.push(message('m6', 0));
-
-        emitSession(client, [maxAgeRoom(store)]);
-        await flush();
-
-        expect(window.items.map((m: any) => m.id)).toEqual(['m3', 'm4', 'm5', 'm6']);
-    });
-
-    test('keeps the loaded history when a short latest page does not reach it', async () => {
-        const store = [
-            message('m1', 5), message('m2', 4), message('m3', 3),
-            message('m4', 2), message('m5', 1),
-        ];
-        const { client, window } = await openWindowWithHistory(store);
-
-        // The server dropped everything the client had loaded and holds a single
-        // message written during the downtime. The loaded messages are still
-        // inside the room time window, so they must not disappear from the
-        // window just because they are not in the (partial) page.
-        store.length = 0;
-        store.push(message('m6', 0));
-
-        emitSession(client, [maxAgeRoom(store)]);
-        await flush();
-
-        expect(window.state).toBe(WindowState.LATEST);
-        expect(window.items.map((m: any) => m.id))
-            .toEqual(['m1', 'm2', 'm3', 'm4', 'm5', 'm6']);
-    });
-
-    test('keeps the loaded history when nothing was written during the downtime', async () => {
-        const store = [
-            message('m1', 5), message('m2', 4), message('m3', 3),
-            message('m4', 2), message('m5', 1),
-        ];
-        const { client, window } = await openWindowWithHistory(store);
-
-        // Empty latest page - the room is quiet and the server no longer keeps
-        // the messages the client has. Emptying the window here is exactly what
-        // must not happen.
-        store.length = 0;
-
-        emitSession(client, [maxAgeRoom(store)]);
-        await flush();
-
-        expect(window.state).toBe(WindowState.LATEST);
-        expect(window.items.map((m: any) => m.id)).toEqual(['m1', 'm2', 'm3', 'm4', 'm5']);
-    });
-
-    test('deduplicates the messages returned in both the page and the local history', async () => {
-        const store = [
-            message('m1', 5), message('m2', 4), message('m3', 3),
-            message('m4', 2), message('m5', 1),
-        ];
-        const { client, window } = await openWindowWithHistory(store);
-
-        // Same messages come back in the page (nothing new was written).
-        emitSession(client, [maxAgeRoom(store)]);
-        await flush();
-
-        expect(window.items.map((m: any) => m.id)).toEqual(['m1', 'm2', 'm3', 'm4', 'm5']);
-    });
-
-    test('marks the gap when the missed messages do not fit in a single page', async () => {
-        const store = [
-            message('m1', 5), message('m2', 4), message('m3', 3),
-            message('m4', 2), message('m5', 1),
-        ];
-        const { client, window } = await openWindowWithHistory(store);
-
-        // More messages than a single page arrived, so the loaded ones cannot be
-        // stitched to the fetched page: m6 was never fetched.
-        store.push(message('m6', 0), message('m7', 0), message('m8', 0), message('m9', 0));
-
-        emitSession(client, [maxAgeRoom(store)]);
-        await flush();
-
-        expect(window.state).toBe(WindowState.LATEST);
-        expect(window.items.map((m: any) => m.id))
-            .toEqual(['m1', 'm2', 'm3', 'm4', 'm5', 'm7', 'm8', 'm9']);
-        expect(window.gaps).toEqual(['m7']);
-    });
-
-    test('does not mark a gap when the loaded history is continuous', async () => {
-        const store = [
-            message('m1', 5), message('m2', 4), message('m3', 3),
-            message('m4', 2), message('m5', 1),
-        ];
-        const { client, window } = await openWindowWithHistory(store);
-
-        store.push(message('m6', 0));
-
-        emitSession(client, [maxAgeRoom(store)]);
-        await flush();
-
-        expect(window.gaps).toEqual([]);
-    });
-
-    test('a full history room still resets to the latest page', async () => {
-        const store = [
-            message('m1', 5), message('m2', 4), message('m3', 3),
-            message('m4', 2), message('m5', 1),
-        ];
-        const { client, tracker } = createTracker();
-        serveMessages(client, store);
-
-        const fullRoom = () => createRoom('M', {
-            defaultTopic: { id: 'topic-M', messageCount: store.length, lastMessage: store[store.length - 1] },
-        });
-
-        emitSession(client, [fullRoom()]);
-
-        const history = await tracker.rooms.messages.getRoomHistory('M');
-        const window = await history.getMessagesWindow('topic-M');
-        window.fetchLimit = 3;
-
-        await window.resetToLatest();
-        await window.fetchPrevious();
-        client.sent.length = 0;
-
-        emitSession(client, [fullRoom()]);
-        await flush();
-
-        // Persisted history can always be traversed back, so the window is just
-        // reset - unchanged behaviour.
-        expect(window.items.map((m: any) => m.id)).toEqual(['m3', 'm4', 'm5']);
-    });
-
-    test('ephemeral history is never resynced, even when asked directly', async () => {
-        const { client, tracker } = createTracker();
-        client.respondTo('GetMessages', () => ({ messages: [{ id: 'x1' }] }));
-
-        emitSession(client, [createRoom('E', { history: { mode: 'Ephemeral' } })]);
-
-        const history = await tracker.rooms.messages.getRoomHistory('E');
-        const window = await history.getMessagesWindow('topic-E');
-        client.sent.length = 0;
-
-        await window.resyncToLatest();
-
-        expect(client.countSent('GetMessages')).toBe(0);
-        expect(window.items).toHaveLength(0);
-    });
-});
-
 describe('reconnect - SpacesManager', () => {
     test('reconciles roles in place and drops only removed spaces', async () => {
         const { client, tracker } = createTracker();