polfan-server-js-client 0.2.109 → 0.2.111

package/src/state-tracker/RoomsManager.ts

@@ -303,16 +303,33 @@ export class RoomsManager {
                     ev.members,
                 )
             ]);
+        } else {
+            // Reconcile into the existing (bound) collection so a reconnect
+            // refetch updates it in place instead of leaving stale members.
+            this.members.get(ev.id).reconcile(...ev.members);
         }
     }
 
     private handleSession(ev: Session): void {
-        this.list.deleteAll();
-        this.topics.deleteAll();
-        this.topicsPromises.forgetAll();
-        this.members.deleteAll();
+        const stateRoomIds = new Set(ev.state.rooms.map(room => room.id));
+
+        // Remove only rooms that were left/deleted on the server during the
+        // downtime, reusing the cascade cleanup (members, topics, followed
+        // topics). Surviving rooms keep their identity and bindings.
+        const removedRoomIds = this.list.items
+            .filter(room => ! stateRoomIds.has(room.id))
+            .map(room => room.id);
+        if (removedRoomIds.length) {
+            this.deleteRoom(...removedRoomIds);
+        }
+
+        // Invalidate lazy caches so the next access refetches fresh data, but
+        // keep the collection objects: handleRoomMembers reconciles into them,
+        // so bound views refresh in place without blanking.
         this.membersPromises.forgetAll();
+        this.topicsPromises.forgetAll();
 
+        // Upsert surviving/new rooms from the authoritative snapshot.
         this.addJoinedRooms(...ev.state.rooms);
 
         this.deferredSession.resolve();

package/src/state-tracker/SpacesManager.ts

@@ -227,14 +227,20 @@ export class SpacesManager {
                 ev.id,
                 new ObservableIndexedObjectCollection(member => member?.user.id, ev.members)
             ]);
+        } else {
+            // Reconcile into the existing (bound) collection so a reconnect
+            // refetch updates it in place instead of leaving stale members.
+            this.members.get(ev.id).reconcile(...ev.members);
         }
     }
 
     private handleSpaceRooms(ev: SpaceRooms): void {
-        if (!this.rooms.has(ev.id)) {
+        if (! this.rooms.has(ev.id)) {
             this.rooms.set([ev.id, new ObservableIndexedObjectCollection('id', ev.summaries)]);
-            ev.summaries.forEach(summary => this.roomIdToSpaceId.set([summary.id, ev.id]));
+        } else {
+            this.rooms.get(ev.id).reconcile(...ev.summaries);
         }
+        ev.summaries.forEach(summary => this.roomIdToSpaceId.set([summary.id, ev.id]));
     }
 
     private async handleRoomSummaryUpdated(ev: RoomSummaryUpdated): Promise<void> {
@@ -286,15 +292,36 @@ export class SpacesManager {
     }
 
     private handleSession(ev: Session): void {
-        this.list.deleteAll();
-        this.roles.deleteAll();
-        this.rooms.deleteAll();
+        const stateSpaceIds = new Set(ev.state.spaces.map(space => space.id));
+
+        // Remove only spaces that were left/deleted on the server during the
+        // downtime, reusing the cascade cleanup (roles, rooms, members, index).
+        const removedSpaceIds = this.list.items
+            .filter(space => ! stateSpaceIds.has(space.id))
+            .map(space => space.id);
+        for (const spaceId of removedSpaceIds) {
+            this.handleSpaceDeleted({ id: spaceId } as SpaceDeleted);
+        }
+
+        // Invalidate lazy caches (rooms/members) but keep their objects so the
+        // next access refetches and reconciles them in place.
         this.roomsPromises.forgetAll();
-        this.members.deleteAll();
         this.membersPromises.forgetAll();
-        this.roomIdToSpaceId.deleteAll();
 
-        this.addJoinedSpaces(...ev.state.spaces);
+        // Reconcile roles in place (kept, possibly bound object) and upsert the
+        // spaces from the authoritative snapshot.
+        for (const space of ev.state.spaces) {
+            if (this.roles.has(space.id)) {
+                this.roles.get(space.id).reconcile(...space.roles);
+            } else {
+                this.roles.set([
+                    space.id,
+                    new ObservableIndexedObjectCollection<Role>('id', space.roles),
+                ]);
+            }
+        }
+
+        this.list.set(...ev.state.spaces);
 
         this.deferredSession.resolve();
     }

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/pending-commands.test.ts

@@ -0,0 +1,171 @@
+import {PromiseRegistry} from "../src/state-tracker/AsyncUtils";
+import {AbstractChatClient} from "../src/AbstractChatClient";
+import {TraversableRemoteCollection, WindowState} from "../src/state-tracker/TopicHistoryWindow";
+import {Envelope} from "../src/types/src";
+
+/**
+ * A command issued while the client is offline (or one that is still in flight
+ * when the socket drops) must always settle. Leaving it pending strands every
+ * caller awaiting it - including the state tracker's cached lookups and the
+ * history window's `ongoing` guard, which would keep a view stuck on a loader
+ * (or permanently empty) even after a successful reconnect.
+ */
+
+class TestableChatClient extends AbstractChatClient {
+    public async send(type: any, data: any): Promise<any> {
+        const envelope = this.createEnvelope(type, data);
+        return this.createPromiseFromCommandEnvelope(envelope as any);
+    }
+
+    public respond(ref: string, type: string, data: any): void {
+        this.handleIncomingEnvelope({ ref, type, data } as Envelope);
+    }
+
+    public dropConnection(error: Error): void {
+        this.failAwaitingResponses(error);
+    }
+
+    public get pendingCount(): number {
+        return this.awaitingResponse.size;
+    }
+}
+
+describe('pending commands settle on connection loss', () => {
+    test('in-flight commands reject instead of hanging forever', async () => {
+        const client = new TestableChatClient();
+
+        const first = client.send('GetMessages', {});
+        const second = client.send('GetRoomMembers', {});
+
+        expect(client.pendingCount).toBe(2);
+
+        client.dropConnection(new Error('Connection closed'));
+
+        await expect(first).rejects.toThrow('Connection closed');
+        await expect(second).rejects.toThrow('Connection closed');
+        expect(client.pendingCount).toBe(0);
+    });
+
+    test('commands answered before the drop are unaffected', async () => {
+        const client = new TestableChatClient();
+
+        const answered = client.send('GetMessages', {});
+        client.respond('1', 'Messages', { messages: [] });
+
+        const inFlight = client.send('GetRoomMembers', {});
+        client.dropConnection(new Error('Connection closed'));
+
+        await expect(answered).resolves.toEqual({ data: { messages: [] }, error: null });
+        await expect(inFlight).rejects.toThrow('Connection closed');
+    });
+});
+
+describe('PromiseRegistry does not cache failures', () => {
+    test('a rejected lookup is forgotten so the next access retries', async () => {
+        const registry = new PromiseRegistry();
+        let attempts = 0;
+
+        const run = async () => {
+            registry.registerByFunction(async () => {
+                attempts++;
+                if (attempts === 1) {
+                    throw new Error('offline');
+                }
+                return 'ok';
+            }, 'key');
+
+            return registry.get('key');
+        };
+
+        // First attempt fails while "offline".
+        await expect(run()).rejects.toThrow('offline');
+
+        // The failed entry must not be cached, otherwise every later access
+        // would replay the same rejection forever.
+        expect(registry.notExist('key')).toBe(true);
+
+        await expect(run()).resolves.toBe('ok');
+        expect(attempts).toBe(2);
+    });
+
+    test('a successful lookup stays cached', async () => {
+        const registry = new PromiseRegistry();
+        let attempts = 0;
+
+        registry.registerByFunction(async () => {
+            attempts++;
+            return 'ok';
+        }, 'key');
+
+        await registry.get('key');
+
+        expect(registry.has('key')).toBe(true);
+        expect(attempts).toBe(1);
+    });
+
+    test('a newer entry for the same key is not dropped by an older failure', async () => {
+        const registry = new PromiseRegistry();
+
+        const failing = Promise.reject(new Error('offline'));
+        registry.register(failing, 'key');
+        await expect(registry.get('key')).rejects.toThrow('offline');
+
+        const succeeding = Promise.resolve('ok');
+        registry.register(succeeding, 'key');
+
+        // Let the older rejection's cleanup handler run.
+        await new Promise(resolve => setTimeout(resolve, 0));
+
+        expect(registry.has('key')).toBe(true);
+        await expect(registry.get('key')).resolves.toBe('ok');
+    });
+});
+
+describe('history window survives a failed fetch', () => {
+    interface SimpleMessage { id: number }
+
+    class FlakyWindow extends TraversableRemoteCollection<SimpleMessage> {
+        public shouldFail = false;
+
+        public constructor() {
+            super('id');
+        }
+
+        public createMirror(): TraversableRemoteCollection<SimpleMessage> {
+            throw new Error('Method not implemented.');
+        }
+
+        protected async fetchLatestItems(): Promise<SimpleMessage[]> {
+            if (this.shouldFail) {
+                throw new Error('Connection closed before the command was answered');
+            }
+            return [{ id: 1 }, { id: 2 }];
+        }
+
+        protected async fetchItemsBefore(): Promise<SimpleMessage[] | null> { return []; }
+        protected async fetchItemsAfter(): Promise<SimpleMessage[] | null> { return []; }
+        protected async fetchItemsAround(): Promise<SimpleMessage[] | null> { return []; }
+        protected async isLatestItemLoaded(): Promise<boolean> { return true; }
+    }
+
+    test('a rejected fetch leaves the window reusable, not permanently blocked', async () => {
+        const window = new FlakyWindow();
+
+        // Simulates opening a room while the client is offline.
+        window.shouldFail = true;
+        await expect(window.resetToLatest()).rejects.toThrow('Connection closed');
+
+        // The failure must not leave the internal `ongoing` guard set, which
+        // would make every later fetch a silent no-op and strand the view on an
+        // empty window after the reconnect.
+        expect(window.state).toBe(WindowState.LIVE);
+        expect(window.length).toBe(0);
+
+        // Retry after reconnecting must actually fetch.
+        window.shouldFail = false;
+        await window.resetToLatest();
+
+        expect(window.state).toBe(WindowState.LATEST);
+        expect(window.items.map(item => item.id)).toEqual([1, 2]);
+    });
+})