polfan-server-js-client 0.2.105 → 0.2.107

package/src/state-tracker/FollowedTopicsManager.ts

@@ -23,6 +23,12 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
     private readonly deferredSession = new DeferredTask();
     private readonly summariesCache = new Map<string, { mentionCount: number, isUnread: boolean }>();
 
+    /**
+     * Rooms whose cached followed-topics are stale after a reconnect and must
+     * be refetched (and reconciled in place) the next time they are accessed.
+     */
+    private readonly staleRooms = new Set<string>();
+
     public constructor(private tracker: ChatStateTracker) {
         super();
 
@@ -57,8 +63,8 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
             return;
         }
 
-        const isAlreadyCached = roomIds.every(roomId => this.followedTopics.has(roomId));
-        if (isAlreadyCached) {
+        const needsFetch = roomIds.some(roomId => ! this.followedTopics.has(roomId) || this.staleRooms.has(roomId));
+        if (! needsFetch) {
             return;
         }
 
@@ -69,7 +75,7 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
                 const result = await this.tracker.client.send('GetFollowedTopics', {location: {spaceId}});
                 if (result.error) throw result.error;
 
-                this.setFollowedTopicsArray(roomIds, result.data.followedTopics);
+                this.reconcileRoomsFollowedTopics(roomIds, result.data.followedTopics);
             }, spaceRegistryKey);
         }
 
@@ -85,7 +91,7 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
             return undefined;
         }
 
-        if (! this.followedTopics.has(roomId)) {
+        if (! this.followedTopics.has(roomId) || this.staleRooms.has(roomId)) {
             if (this.followedTopicsPromises.notExist(roomId)) {
                 this.followedTopicsPromises.registerByFunction(async () => {
                     const result = await this.tracker.client.send('GetFollowedTopics', {location: {roomId}});
@@ -94,7 +100,8 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
                         throw result.error;
                     }
 
-                    this.setFollowedTopicsArray([roomId], result.data.followedTopics);
+                    this.applyRoomFollowedTopics(roomId, result.data.followedTopics);
+                    this.invalidateUnreadSummaries(roomId);
                 }, roomId);
             }
 
@@ -199,7 +206,13 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
     }
 
     private handleSession(ev: Session): void {
-        this.followedTopics.deleteAll();
+        // Keep cached followed-topic collections (they drive unread indicators
+        // that would otherwise blank on reconnect), but mark them stale and drop
+        // the fetch guards so the next access/caching refetches and reconciles
+        // them in place.
+        for (const roomId of this.followedTopics.items.keys()) {
+            this.staleRooms.add(roomId);
+        }
         this.followedTopicsPromises.forgetAll();
         this.invalidateUnreadSummaries();
         this.deferredSession.resolve();
@@ -351,6 +364,40 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
         this.invalidateUnreadSummaries(ev.message.location.roomId, ev.message.location.topicId);
     }
 
+    /**
+     * Reconcile the followed-topics collection for a single room to exactly
+     * match the provided list (upsert present, drop absent) without emitting an
+     * intermediate empty state, and clear its stale marker. Does not touch the
+     * unread summaries cache - callers decide how to invalidate it.
+     */
+    private applyRoomFollowedTopics(roomId: string, followedTopics: FollowedTopic[]): void {
+        if (! this.followedTopics.has(roomId)) {
+            this.followedTopics.set([roomId, new ObservableIndexedObjectCollection<FollowedTopic>(
+                followedTopic => followedTopic.location.topicId
+            )]);
+        }
+
+        this.followedTopics.get(roomId).reconcile(...followedTopics);
+        this.staleRooms.delete(roomId);
+    }
+
+    /**
+     * Reconcile a batch of rooms from a single bulk GetFollowedTopics response.
+     * Rooms with no followed topics in the response are reconciled to empty, so
+     * topics unfollowed/removed during the downtime are correctly dropped.
+     */
+    private reconcileRoomsFollowedTopics(roomIds: string[], followedTopics: FollowedTopic[]): void {
+        const roomToTopics: {[roomId: string]: FollowedTopic[]} = {};
+
+        followedTopics.forEach(followedTopic => {
+            (roomToTopics[followedTopic.location.roomId] ??= []).push(followedTopic);
+        });
+
+        roomIds.forEach(roomId => this.applyRoomFollowedTopics(roomId, roomToTopics[roomId] ?? []));
+
+        this.invalidateUnreadSummariesForRooms(roomIds);
+    }
+
     private setFollowedTopicsArray(roomIds: string[], followedTopics: FollowedTopic[]): void {
         const roomToTopics: {[roomId: string]: FollowedTopic[]} = {};
 
@@ -378,6 +425,7 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
     private clearRoomFollowedTopicsStructures(roomId: string): void {
         this.followedTopics.delete(roomId);
         this.followedTopicsPromises.forget(roomId);
+        this.staleRooms.delete(roomId);
         this.invalidateUnreadSummaries(roomId);
     }
 }

package/src/state-tracker/MessagesManager.ts

@@ -71,8 +71,27 @@ export class MessagesManager {
     }
 
     private handleSession(ev: Session): void {
-        this.roomHistories.deleteAll();
-        ev.state.rooms.forEach(room => this.createHistoryForNewRoom(room));
+        const stateRoomIds = new Set(ev.state.rooms.map(room => room.id));
+
+        // Drop histories only for rooms that no longer exist server-side.
+        for (const roomId of Array.from(this.roomHistories.items.keys())) {
+            if (! stateRoomIds.has(roomId)) {
+                this.roomHistories.delete(roomId);
+            }
+        }
+
+        // Keep existing histories (preserving loaded messages and, crucially,
+        // live-only ephemeral history), create histories for newly joined
+        // rooms, and resync survivors against the fresh room snapshot.
+        for (const room of ev.state.rooms) {
+            const history = this.roomHistories.get(room.id);
+            if (history) {
+                void history.resync(room);
+            } else {
+                this.createHistoryForNewRoom(room);
+            }
+        }
+
         this.deferredSession.resolve();
     }
 }

package/src/state-tracker/PermissionsManager.ts

@@ -308,7 +308,11 @@ export class PermissionsManager extends EventTarget<PermissionsManagerEventMap>
     }
 
     private handleSession(ev: Session): void {
-        this.overwrites.deleteAll();
+        // Drop the fetch guards so permission checks recompute against fresh
+        // overwrites (getOverwrites refetches and upserts on the next access),
+        // and notify consumers to recompute so bound permission UI is never
+        // left showing stale results after a reconnect.
         this.overwritesPromises.forgetAll();
+        this.emit('change');
     }
 }

package/src/state-tracker/RelationshipsManager.ts

@@ -43,10 +43,9 @@ export class RelationshipsManager {
     }
 
     private handleRelationships(ev: Relationships): void {
-        this.relationships.deleteAll();
-        ev.relationships.forEach(relationship => {
-            this.relationships.set(relationship);
-        });
+        // Full list from the server: reconcile in place so a reconnect refetch
+        // updates a bound (visible) list without an intermediate empty state.
+        this.relationships.reconcile(...ev.relationships);
     }
 
     private handleNewRelationship(ev: NewRelationship): void {
@@ -62,7 +61,8 @@ export class RelationshipsManager {
     }
 
     private handleSession(): void {
+        // Keep the (possibly bound) collection; just drop the fetch guard so the
+        // next get() refetches and reconciles it in place.
         this.promises.forgetAll();
-        this.relationships.deleteAll();
     }
 }

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} from "./TopicHistoryWindow";
+import {TopicHistoryWindow, WindowState} from "./TopicHistoryWindow";
 
 export class RoomMessagesHistory {
     private historyWindows = new IndexedCollection<string, TopicHistoryWindow>();
@@ -39,6 +39,46 @@ 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,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();