polfan-server-js-client 0.2.105 → 0.2.106

package/src/state-tracker/TopicHistoryWindow.ts

@@ -111,8 +111,8 @@ export abstract class TraversableRemoteCollection<
 
     public abstract createMirror(): TraversableRemoteCollection<ItemT, EventMapT>;
 
-    public async resetToLatest(): Promise<void> {
-        if (this.internalState.ongoing || this.internalState.current === WindowState.LATEST) {
+    public async resetToLatest(force: boolean = false): Promise<void> {
+        if (this.internalState.ongoing || (! force && this.internalState.current === WindowState.LATEST)) {
             return;
         }
 
@@ -340,11 +340,11 @@ export class TopicHistoryWindow extends TraversableRemoteCollection<
         }
     }
 
-    public async resetToLatest(): Promise<void> {
+    public async resetToLatest(force: boolean = false): Promise<void> {
         if (this.internalState.traverseLock) {
             return;
         }
-        return super.resetToLatest();
+        return super.resetToLatest(force);
     }
 
     public async fetchNext(): Promise<void> {

package/src/state-tracker/UsersManager.ts

@@ -33,7 +33,9 @@ export class UsersManager {
     }
 
     private handleSession(session: Session): void {
-        this.users.deleteAll();
+        // Keep the "seen users" cache across reconnects so bound user lists do
+        // not blank out; just ensure our own user is present/updated. Stale
+        // entries are refreshed as member/message collections refetch.
         this.handleUsers([session.user]);
     }
 

package/tests/collections.test.ts

@@ -759,4 +759,96 @@ describe('ObservableIndexedObjectCollection', () => {
         expect(mirror.get('2')).toBeDefined();
         expect(mirror.length).toBe(2);
     });
+
+    test('reconcile - upserts new/changed items and deletes absent ones', () => {
+        const collection = new ObservableIndexedObjectCollection<TestItem>('id', [
+            createItem('1', 'first'),
+            createItem('2', 'second'),
+            createItem('3', 'third'),
+        ]);
+
+        // Keep 1 (changed), keep 3 (unchanged), drop 2, add 4.
+        collection.reconcile(
+            createItem('1', 'first-renamed'),
+            createItem('3', 'third'),
+            createItem('4', 'fourth'),
+        );
+
+        expect(collection.length).toBe(3);
+        expect(collection.get('1')?.name).toBe('first-renamed');
+        expect(collection.get('2')).toBeUndefined();
+        expect(collection.get('3')?.name).toBe('third');
+        expect(collection.get('4')?.name).toBe('fourth');
+    });
+
+    test('reconcile - emits a single change event with set and deleted ids', () => {
+        const collection = new ObservableIndexedObjectCollection<TestItem>('id', [
+            createItem('1', 'first'),
+            createItem('2', 'second'),
+        ]);
+        const handler = jest.fn();
+        collection.on('change', handler);
+
+        collection.reconcile(createItem('1', 'first'), createItem('3', 'third'));
+
+        expect(handler).toHaveBeenCalledTimes(1);
+        expect(handler).toHaveBeenCalledWith({ setItems: ['1', '3'], deletedItems: ['2'] });
+    });
+
+    test('reconcile - never blanks: existing item stays present the whole time', () => {
+        const collection = new ObservableIndexedObjectCollection<TestItem>('id', [
+            createItem('1', 'first'),
+            createItem('2', 'second'),
+        ]);
+
+        // A change listener that reads the collection while it is being
+        // reconciled must never observe an empty/partial intermediate state.
+        const seenLengths: number[] = [];
+        collection.on('change', () => seenLengths.push(collection.length));
+
+        collection.reconcile(createItem('1', 'first'), createItem('3', 'third'));
+
+        // Only the final state (2 items) is ever visible - no 0-length frame.
+        expect(seenLengths).toEqual([2]);
+    });
+
+    test('reconcile - does not emit when nothing changes structurally on empty input', () => {
+        const collection = new ObservableIndexedObjectCollection<TestItem>('id');
+        const handler = jest.fn();
+        collection.on('change', handler);
+
+        collection.reconcile();
+
+        expect(handler).not.toHaveBeenCalled();
+        expect(collection.length).toBe(0);
+    });
+
+    test('reconcile - reconciling to empty clears the collection', () => {
+        const collection = new ObservableIndexedObjectCollection<TestItem>('id', [
+            createItem('1', 'first'),
+        ]);
+        const handler = jest.fn();
+        collection.on('change', handler);
+
+        collection.reconcile();
+
+        expect(collection.length).toBe(0);
+        expect(handler).toHaveBeenCalledWith({ setItems: [], deletedItems: ['1'] });
+    });
+
+    test('reconcile - preserves collection identity (mirror sees updates)', () => {
+        const collection = new ObservableIndexedObjectCollection<TestItem>('id', [
+            createItem('1', 'first'),
+            createItem('2', 'second'),
+        ]);
+        const mirror = collection.createMirror();
+
+        collection.reconcile(createItem('2', 'second'), createItem('3', 'third'));
+
+        // The mirror shares the same underlying items, so it reflects the
+        // reconcile without being re-created.
+        expect(mirror.get('1')).toBeUndefined();
+        expect(mirror.get('3')?.name).toBe('third');
+        expect(mirror.length).toBe(2);
+    });
 });

package/tests/state-reconnect.test.ts

@@ -0,0 +1,257 @@
+import {EventTarget} from "../src/EventTarget";
+import {RoomsManager} from "../src/state-tracker/RoomsManager";
+import {SpacesManager} from "../src/state-tracker/SpacesManager";
+import {WindowState} from "../src/state-tracker/TopicHistoryWindow";
+
+/**
+ * These tests exercise the reconnect (second `Session`) reconciliation path of
+ * the state tracker: collections must keep their identity, surviving rooms and
+ * spaces must not be wiped and rebuilt, ephemeral message history must be
+ * preserved, and only the entities actually removed on the server may be
+ * dropped. See ChatStateTracker managers `handleSession`.
+ */
+
+type Responder = (data: any) => any;
+
+class FakeClient extends EventTarget {
+    public readonly sent: { type: string; data: any }[] = [];
+    private readonly responders: Record<string, Responder> = {};
+
+    public respondTo(type: string, responder: Responder): void {
+        this.responders[type] = responder;
+    }
+
+    public async send(type: string, data: any): Promise<{ data: any; error: any }> {
+        this.sent.push({ type, data });
+        const responder = this.responders[type];
+        return { data: responder ? responder(data) : undefined, error: null };
+    }
+
+    public countSent(type: string): number {
+        return this.sent.filter(entry => entry.type === type).length;
+    }
+}
+
+const flush = async (): Promise<void> => {
+    // Drain microtasks scheduled by the fire-and-forget resync chain.
+    await new Promise(resolve => setTimeout(resolve, 0));
+    await new Promise(resolve => setTimeout(resolve, 0));
+};
+
+const createRoom = (id: string, overrides: any = {}): any => ({
+    id,
+    spaceId: null,
+    name: id,
+    description: '',
+    type: 'Text',
+    defaultTopic: { id: `topic-${id}`, messageCount: 0, lastMessage: null },
+    recipients: null,
+    flags: 0,
+    stream: null,
+    history: { mode: 'Full' },
+    ...overrides,
+});
+
+const createSpace = (id: string, roles: any[] = []): any => ({
+    id,
+    name: id,
+    roles,
+    defaultRooms: [],
+    systemRoom: null,
+});
+
+const emitSession = (client: FakeClient, rooms: any[], spaces: any[] = []): void => {
+    client.emit('Session', {
+        serverVersion: '1.0.0',
+        protoVersion: '1.0.0',
+        user: { id: 'me' },
+        state: { rooms, spaces },
+    } as any);
+};
+
+const createTracker = () => {
+    const client = new FakeClient();
+    const tracker: any = { client, getMe: async () => ({ id: 'me' }) };
+    tracker.rooms = new RoomsManager(tracker);
+    tracker.spaces = new SpacesManager(tracker);
+    return { client, tracker };
+};
+
+describe('reconnect - RoomsManager', () => {
+    test('preserves the rooms list identity and reconciles membership', async () => {
+        const { client, tracker } = createTracker();
+
+        emitSession(client, [createRoom('A'), createRoom('B')]);
+        const list = await tracker.rooms.get();
+
+        expect(list.items.map((r: any) => r.id).sort()).toEqual(['A', 'B']);
+
+        // Reconnect: B is gone, C joined, A survived (renamed).
+        emitSession(client, [createRoom('A', { name: 'A-renamed' }), createRoom('C')]);
+        const listAfter = await tracker.rooms.get();
+
+        expect(listAfter).toBe(list); // same object -> bindings intact
+        expect(listAfter.items.map((r: any) => r.id).sort()).toEqual(['A', 'C']);
+        expect(listAfter.get('A').name).toBe('A-renamed');
+        expect(listAfter.get('B')).toBeUndefined();
+    });
+
+    test('keeps a member collection object across reconnect and refetches it', async () => {
+        const { client, tracker } = createTracker();
+        client.respondTo('GetRoomMembers', (data: any) => ({
+            id: data.id,
+            members: [
+                { user: { id: 'me' }, spaceMember: null, roles: null, customColor: null, customNick: null, extras: '' },
+                { user: { id: 'u1' }, spaceMember: null, roles: null, customColor: null, customNick: null, extras: '' },
+            ],
+        }));
+
+        emitSession(client, [createRoom('A')]);
+        const membersBefore = await tracker.rooms.getMembers('A');
+        expect(membersBefore.items.map((m: any) => m.user.id).sort()).toEqual(['me', 'u1']);
+        expect(client.countSent('GetRoomMembers')).toBe(1);
+
+        // After reconnect u1 has left; the refetch must reconcile in place.
+        client.respondTo('GetRoomMembers', (data: any) => ({
+            id: data.id,
+            members: [
+                { user: { id: 'me' }, spaceMember: null, roles: null, customColor: null, customNick: null, extras: '' },
+            ],
+        }));
+
+        emitSession(client, [createRoom('A')]);
+        const membersAfter = await tracker.rooms.getMembers('A');
+
+        expect(membersAfter).toBe(membersBefore); // same object -> no blank
+        expect(client.countSent('GetRoomMembers')).toBe(2); // guard was dropped -> refetched
+        expect(membersAfter.items.map((m: any) => m.user.id)).toEqual(['me']);
+    });
+});
+
+describe('reconnect - MessagesManager', () => {
+    const emitNewMessage = (client: FakeClient, roomId: string, topicId: string, id: string): void => {
+        client.emit('NewMessage', {
+            message: {
+                id,
+                type: 'Text',
+                content: '',
+                location: { roomId, topicId },
+                author: { user: { id: 'other' } },
+            },
+        } as any);
+    };
+
+    test('preserves ephemeral live history across reconnect (no refetch, no loss)', async () => {
+        const { client, tracker } = createTracker();
+
+        emitSession(client, [createRoom('E', { history: { mode: 'Ephemeral' } })]);
+
+        const history = await tracker.rooms.messages.getRoomHistory('E');
+        const window = await history.getMessagesWindow('topic-E');
+        expect(window.state).toBe(WindowState.LIVE);
+
+        emitNewMessage(client, 'E', 'topic-E', 'm1');
+        emitNewMessage(client, 'E', 'topic-E', 'm2');
+        expect(window.items.map((m: any) => m.id)).toEqual(['m1', 'm2']);
+
+        client.sent.length = 0;
+
+        // Reconnect - the whole point: ephemeral context must survive.
+        emitSession(client, [createRoom('E', { history: { mode: 'Ephemeral' } })]);
+        await flush();
+
+        const historyAfter = await tracker.rooms.messages.getRoomHistory('E');
+        const windowAfter = await historyAfter.getMessagesWindow('topic-E');
+
+        expect(historyAfter).toBe(history); // history object preserved
+        expect(windowAfter).toBe(window);   // window object preserved
+        expect(windowAfter.items.map((m: any) => m.id)).toEqual(['m1', 'm2']);
+        expect(client.countSent('GetMessages')).toBe(0); // never refetched
+    });
+
+    test('refreshes a LATEST window but leaves an untouched LIVE window alone', async () => {
+        const { client, tracker } = createTracker();
+        client.respondTo('GetMessages', () => ({ messages: [{ id: 'x1' }, { id: 'x2' }] }));
+
+        // R was opened (pulled to LATEST); L was only ever created (LIVE).
+        emitSession(client, [createRoom('R'), createRoom('L')]);
+
+        const rHistory = await tracker.rooms.messages.getRoomHistory('R');
+        const rWindow = await rHistory.getMessagesWindow('topic-R');
+        await rWindow.resetToLatest();
+        expect(rWindow.state).toBe(WindowState.LATEST);
+
+        const lHistory = await tracker.rooms.messages.getRoomHistory('L');
+        const lWindow = await lHistory.getMessagesWindow('topic-L');
+        expect(lWindow.state).toBe(WindowState.LIVE);
+
+        client.sent.length = 0;
+
+        emitSession(client, [createRoom('R'), createRoom('L')]);
+        await flush();
+
+        // LATEST window was refreshed with exactly one request; identity kept.
+        expect((await tracker.rooms.messages.getRoomHistory('R'))).toBe(rHistory);
+        expect(client.sent.filter(e => e.type === 'GetMessages'
+            && e.data.location.roomId === 'R').length).toBe(1);
+        // LIVE window (never pulled by the app) was left untouched.
+        expect(client.sent.filter(e => e.type === 'GetMessages'
+            && e.data.location.roomId === 'L').length).toBe(0);
+    });
+});
+
+describe('reconnect - SpacesManager', () => {
+    test('reconciles roles in place and drops only removed spaces', async () => {
+        const { client, tracker } = createTracker();
+
+        const s1Roles = [
+            { id: 'r1', name: 'everyone', priority: 0, color: '#fff' },
+            { id: 'r2', name: 'mod', priority: 1, color: '#fff' },
+        ];
+        emitSession(client, [], [createSpace('S1', s1Roles), createSpace('S2')]);
+
+        const spaces = await tracker.spaces.get();
+        const rolesS1 = await tracker.spaces.getRoles('S1');
+        expect(spaces.items.map((s: any) => s.id).sort()).toEqual(['S1', 'S2']);
+        expect(rolesS1.items.map((r: any) => r.id).sort()).toEqual(['r1', 'r2']);
+
+        // Reconnect: S2 removed, S3 joined; S1 roles changed (r2 removed, r3 added).
+        const s1RolesNew = [
+            { id: 'r1', name: 'everyone', priority: 0, color: '#fff' },
+            { id: 'r3', name: 'vip', priority: 2, color: '#fff' },
+        ];
+        emitSession(client, [], [createSpace('S1', s1RolesNew), createSpace('S3')]);
+
+        const spacesAfter = await tracker.spaces.get();
+        const rolesS1After = await tracker.spaces.getRoles('S1');
+
+        expect(spacesAfter).toBe(spaces);
+        expect(spacesAfter.items.map((s: any) => s.id).sort()).toEqual(['S1', 'S3']);
+        expect(rolesS1After).toBe(rolesS1); // roles collection identity preserved
+        expect(rolesS1After.items.map((r: any) => r.id).sort()).toEqual(['r1', 'r3']);
+    });
+
+    test('keeps a space member collection across reconnect and refetches it', async () => {
+        const { client, tracker } = createTracker();
+        client.respondTo('GetSpaceMembers', (data: any) => ({
+            id: data.id,
+            members: [{ user: { id: 'me' } }, { user: { id: 'u1' } }],
+        }));
+
+        emitSession(client, [], [createSpace('S1')]);
+        const membersBefore = await tracker.spaces.getMembers('S1');
+        expect(client.countSent('GetSpaceMembers')).toBe(1);
+
+        client.respondTo('GetSpaceMembers', (data: any) => ({
+            id: data.id,
+            members: [{ user: { id: 'me' } }],
+        }));
+
+        emitSession(client, [], [createSpace('S1')]);
+        const membersAfter = await tracker.spaces.getMembers('S1');
+
+        expect(membersAfter).toBe(membersBefore);
+        expect(client.countSent('GetSpaceMembers')).toBe(2);
+        expect(membersAfter.items.map((m: any) => m.user.id)).toEqual(['me']);
+    });
+});