polfan-server-js-client 0.2.107 → 0.2.109

package/src/state-tracker/RoomMessagesHistory.ts

@@ -1,7 +1,7 @@
 import {ChatStateTracker} from "./ChatStateTracker";
 import {NewTopic, Room, RoomUpdated, Topic, TopicDeleted} from "../types/src";
 import {IndexedCollection,} from "../IndexedObjectCollection";
-import {TopicHistoryWindow, WindowState} from "./TopicHistoryWindow";
+import {TopicHistoryWindow} from "./TopicHistoryWindow";
 
 export class RoomMessagesHistory {
     private historyWindows = new IndexedCollection<string, TopicHistoryWindow>();
@@ -39,46 +39,6 @@ export class RoomMessagesHistory {
         return this.historyWindows.get(topicId);
     }
 
-    /**
-     * Re-synchronise this room's history after a reconnect without discarding
-     * the existing window objects (which would blank the UI and, for ephemeral
-     * rooms, permanently drop live-only history).
-     *
-     * The window bindings are preserved; only windows that the application had
-     * actually pulled to the latest page (state === LATEST) are refreshed, with
-     * a single resetToLatest instead of a chain of catch-up requests. Windows
-     * that were never pulled (LIVE) or belong to an ephemeral room are left
-     * untouched so their in-memory context survives the reconnect.
-     */
-    public async resync(room: Room): Promise<void> {
-        this.room = room;
-        this.updateTraverseLock(room);
-
-        if (this.room.defaultTopic) {
-            this.createHistoryWindowForTopic(this.room.defaultTopic);
-        }
-
-        for (const [, window] of Array.from(this.historyWindows.items)) {
-            try {
-                await window.setTraverseLock(this.traverseLock);
-
-                // Ephemeral history lives only in memory (the server does not
-                // persist it), so never refetch/replace it on reconnect.
-                if (this.traverseLock) {
-                    continue;
-                }
-
-                if (window.state === WindowState.LATEST) {
-                    await window.resetToLatest(true);
-                }
-            } catch (_e) {
-                // Best effort: the connection can drop again mid-resync. The
-                // window keeps its current content and stays usable, so the
-                // application can refresh it on demand.
-            }
-        }
-    }
-
     private async handleRoomUpdated(ev: RoomUpdated): Promise<void> {
         if (this.room.id === ev.room.id) {
             this.room = ev.room;

package/src/state-tracker/RoomsManager.ts

@@ -303,33 +303,16 @@ 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 {
-        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.list.deleteAll();
+        this.topics.deleteAll();
         this.topicsPromises.forgetAll();
+        this.members.deleteAll();
+        this.membersPromises.forgetAll();
 
-        // Upsert surviving/new rooms from the authoritative snapshot.
         this.addJoinedRooms(...ev.state.rooms);
 
         this.deferredSession.resolve();

package/src/state-tracker/SpacesManager.ts

@@ -227,20 +227,14 @@ 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)]);
-        } else {
-            this.rooms.get(ev.id).reconcile(...ev.summaries);
+            ev.summaries.forEach(summary => this.roomIdToSpaceId.set([summary.id, ev.id]));
         }
-        ev.summaries.forEach(summary => this.roomIdToSpaceId.set([summary.id, ev.id]));
     }
 
     private async handleRoomSummaryUpdated(ev: RoomSummaryUpdated): Promise<void> {
@@ -292,36 +286,15 @@ export class SpacesManager {
     }
 
     private handleSession(ev: Session): void {
-        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.list.deleteAll();
+        this.roles.deleteAll();
+        this.rooms.deleteAll();
         this.roomsPromises.forgetAll();
+        this.members.deleteAll();
         this.membersPromises.forgetAll();
+        this.roomIdToSpaceId.deleteAll();
 
-        // 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.addJoinedSpaces(...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(force: boolean = false): Promise<void> {
-        if (this.internalState.ongoing || (! force && this.internalState.current === WindowState.LATEST)) {
+    public async resetToLatest(): Promise<void> {
+        if (this.internalState.ongoing || this.internalState.current === WindowState.LATEST) {
             return;
         }
 
@@ -340,11 +340,11 @@ export class TopicHistoryWindow extends TraversableRemoteCollection<
         }
     }
 
-    public async resetToLatest(force: boolean = false): Promise<void> {
+    public async resetToLatest(): Promise<void> {
         if (this.internalState.traverseLock) {
             return;
         }
-        return super.resetToLatest(force);
+        return super.resetToLatest();
     }
 
     public async fetchNext(): Promise<void> {

package/src/state-tracker/UsersManager.ts

@@ -33,9 +33,7 @@ export class UsersManager {
     }
 
     private handleSession(session: Session): void {
-        // 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.users.deleteAll();
         this.handleUsers([session.user]);
     }
 

package/tests/collections.test.ts

@@ -759,96 +759,4 @@ 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

@@ -1,171 +0,0 @@
-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]);
-    });
-})