polfan-server-js-client 0.2.105 → 0.2.107

package/build/types/AbstractChatClient.d.ts

@@ -14,6 +14,16 @@ export declare abstract class AbstractChatClient<AdditionalEvents extends ExtraE
     protected createPromiseFromCommandEnvelope<CommandT extends keyof CommandsMap>(envelope: Envelope<CommandRequest<CommandT>>): Promise<CommandResult<CommandResponse<CommandT>>>;
     protected handleIncomingEnvelope(envelope: Envelope): void;
     protected handleEnvelopeSendError(envelope: Envelope, error: any): void;
+    /**
+     * Reject every command that is still waiting for a response.
+     *
+     * Call this whenever the transport can no longer deliver an answer (the
+     * connection dropped). The server will never reply to those commands, so
+     * leaving them pending would hang every caller awaiting them forever -
+     * including cached lookups in the state tracker, which would then keep a
+     * view stuck on a loader even after a successful reconnect.
+     */
+    protected failAwaitingResponses(error: any): void;
 }
 export type CommandResult<ResultT> = {
     data?: ResultT;

package/build/types/IndexedObjectCollection.d.ts

@@ -51,6 +51,14 @@ export declare class ObservableIndexedObjectCollection<ItemT, EventMapT extends
     set(...items: ItemT[]): void;
     delete(...ids: string[]): void;
     deleteAll(): void;
+    /**
+     * Bring the collection to exactly match the provided items: upsert every
+     * provided item and remove any existing item whose id is not present in the
+     * provided set. Emits at most a single `change` event describing both the
+     * set and the deleted ids, so bound consumers can update in place without
+     * ever observing an intermediate empty state (unlike deleteAll + set).
+     */
+    reconcile(...items: ItemT[]): void;
     createMirror(): ObservableIndexedObjectCollection<ItemT, EventMapT>;
     on<EventName extends keyof EventMapT & string>(eventName: EventName, handler: EventHandler<EventMapT[EventName]>): this;
     once<EventName extends keyof EventMapT & string>(eventName: EventName, handler: EventHandler<EventMapT[EventName]>): this;

package/build/types/WebSocketChatClient.d.ts

@@ -45,7 +45,13 @@ export declare class WebSocketChatClient extends AbstractChatClient<Pick<WebSock
     protected sendQueue: Envelope[];
     protected connectingTimeoutId: any;
     protected authenticated: boolean;
-    protected authenticatedResolvers: [() => void, (error: Error) => void];
+    protected authenticatedResolvers: [() => void, (error: Error) => void] | null;
+    /**
+     * Pending promise returned by connect(). Kept until the client is either
+     * authenticated or gives up, so that an automatic reconnect settles the
+     * original caller instead of stranding it on a superseded promise.
+     */
+    protected connectPromise: Promise<void> | null;
     protected pingMonitorInterval?: NodeJS.Timeout;
     protected inFlightPingTimeout: NodeJS.Timeout;
     protected lastReceivedMessageAt?: number;
@@ -57,6 +63,16 @@ export declare class WebSocketChatClient extends AbstractChatClient<Pick<WebSock
     private sendEnvelope;
     private onMessage;
     private onClose;
+    /**
+     * Resolve (or reject, when an error is given) a pending connect() promise.
+     * No-op when there is nothing pending.
+     */
+    private settleConnect;
+    /**
+     * Reject every command that has not been answered yet - both the ones still
+     * waiting in the send queue and the ones already sent to the server.
+     */
+    private failPendingCommands;
     private sendFromQueue;
     private triggerConnectionTimeout;
     private isConnectingWsState;

package/build/types/state-tracker/FollowedTopicsManager.d.ts

@@ -11,6 +11,11 @@ export declare class FollowedTopicsManager extends EventTarget<EventMap> {
     private readonly followedTopicsPromises;
     private readonly deferredSession;
     private readonly summariesCache;
+    /**
+     * 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;
     constructor(tracker: ChatStateTracker);
     /**
      * Cache followed topics for all joined rooms in a space and fetch them in bulk if necessary.
@@ -58,6 +63,19 @@ export declare class FollowedTopicsManager extends EventTarget<EventMap> {
     private invalidateUnreadSummaries;
     private invalidateUnreadSummariesForRooms;
     private updateLocallyFollowedTopicOnNewMessage;
+    /**
+     * 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;
+    /**
+     * 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;
     private setFollowedTopicsArray;
     private clearRoomFollowedTopicsStructures;
 }

package/build/types/state-tracker/RoomMessagesHistory.d.ts

@@ -13,6 +13,18 @@ export declare class RoomMessagesHistory {
      * @param peek If true, do not create a cache for this topic and do not allow it to collect new messages.
      */
     getMessagesWindow(topicId: string, peek?: boolean): Promise<TopicHistoryWindow | undefined>;
+    /**
+     * 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.
+     */
+    resync(room: Room): Promise<void>;
     private handleRoomUpdated;
     private handleNewTopic;
     private handleTopicDeleted;

package/build/types/state-tracker/TopicHistoryWindow.d.ts

@@ -64,7 +64,7 @@ export declare abstract class TraversableRemoteCollection<ItemT, EventMapT exten
     get hasLatest(): boolean;
     get hasOldest(): boolean;
     abstract createMirror(): TraversableRemoteCollection<ItemT, EventMapT>;
-    resetToLatest(): Promise<void>;
+    resetToLatest(force?: boolean): Promise<void>;
     fetchPrevious(): Promise<void>;
     fetchNext(): Promise<void>;
     jumpTo(id: string): Promise<void>;
@@ -99,7 +99,7 @@ export declare class TopicHistoryWindow extends TraversableRemoteCollection<Mess
     createMirror(): TopicHistoryWindow;
     get isTraverseLocked(): boolean;
     setTraverseLock(lock: boolean): Promise<void>;
-    resetToLatest(): Promise<void>;
+    resetToLatest(force?: boolean): Promise<void>;
     fetchNext(): Promise<void>;
     fetchPrevious(): Promise<void>;
     jumpTo(id: string): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polfan-server-js-client",
-  "version": "0.2.105",
+  "version": "0.2.107",
   "description": "JavaScript client library for handling communication with Polfan chat server.",
   "author": "Jarosław Żak",
   "license": "MIT",

package/src/AbstractChatClient.ts

@@ -165,6 +165,28 @@ export abstract class AbstractChatClient<AdditionalEvents extends ExtraEventMap
         this.awaitingResponse.get(envelope.ref)[1](error);
         this.awaitingResponse.delete(envelope.ref);
     }
+
+    /**
+     * Reject every command that is still waiting for a response.
+     *
+     * Call this whenever the transport can no longer deliver an answer (the
+     * connection dropped). The server will never reply to those commands, so
+     * leaving them pending would hang every caller awaiting them forever -
+     * including cached lookups in the state tracker, which would then keep a
+     * view stuck on a loader even after a successful reconnect.
+     */
+    protected failAwaitingResponses(error: any): void {
+        if (! this.awaitingResponse.size) {
+            return;
+        }
+
+        const pending = Array.from(this.awaitingResponse.values());
+        this.awaitingResponse.clear();
+
+        for (const [, reject] of pending) {
+            reject(error);
+        }
+    }
 }
 
 export type CommandResult<ResultT> = {data?: ResultT, error?: ErrorType};

package/src/IndexedObjectCollection.ts

@@ -226,6 +226,37 @@ export class ObservableIndexedObjectCollection<
         }
     }
 
+    /**
+     * Bring the collection to exactly match the provided items: upsert every
+     * provided item and remove any existing item whose id is not present in the
+     * provided set. Emits at most a single `change` event describing both the
+     * set and the deleted ids, so bound consumers can update in place without
+     * ever observing an intermediate empty state (unlike deleteAll + set).
+     */
+    public reconcile(...items: ItemT[]) {
+        const incomingIds = new Set(items.map(item => this.getId(item)));
+        const deletedItems: string[] = [];
+
+        for (const existing of this.items) {
+            const id = this.getId(existing);
+            if (! incomingIds.has(id)) {
+                deletedItems.push(id);
+            }
+        }
+
+        if (! items.length && ! deletedItems.length) {
+            return;
+        }
+
+        this._items.delete(...deletedItems);
+        super.set(...items);
+
+        this.eventTarget.emit('change', {
+            setItems: items.map(item => this.getId(item)),
+            deletedItems,
+        });
+    }
+
     public createMirror(): ObservableIndexedObjectCollection<ItemT, EventMapT> {
         const copy = new ObservableIndexedObjectCollection<ItemT, EventMapT>(this.id);
         copy.eventTarget = this.eventTarget;

package/src/WebSocketChatClient.ts

@@ -48,7 +48,13 @@ export class WebSocketChatClient extends AbstractChatClient<Pick<WebSocketEventM
     protected sendQueue: Envelope[] = [];
     protected connectingTimeoutId: any;
     protected authenticated: boolean;
-    protected authenticatedResolvers: [() => void, (error: Error) => void];
+    protected authenticatedResolvers: [() => void, (error: Error) => void] | null = null;
+    /**
+     * Pending promise returned by connect(). Kept until the client is either
+     * authenticated or gives up, so that an automatic reconnect settles the
+     * original caller instead of stranding it on a superseded promise.
+     */
+    protected connectPromise: Promise<void> | null = null;
     protected pingMonitorInterval?: NodeJS.Timeout;
     protected inFlightPingTimeout: NodeJS.Timeout;
     protected lastReceivedMessageAt?: number;
@@ -67,9 +73,14 @@ export class WebSocketChatClient extends AbstractChatClient<Pick<WebSocketEventM
 
     public async connect(): Promise<void> {
         if (this.isOpenWsState() || this.isConnectingWsState()) {
-            return;
+            return this.connectPromise ?? undefined;
         }
 
+        // Reuse the promise of an attempt that has not settled yet (an
+        // automatic reconnect), so the caller that started connecting is
+        // resolved by whichever attempt eventually authenticates.
+        this.connectPromise ??= new Promise<void>((...args) => this.authenticatedResolvers = args);
+
         const params = new URLSearchParams(this.options.queryParams ?? {});
         params.set('token', this.options.token);
 
@@ -81,11 +92,12 @@ export class WebSocketChatClient extends AbstractChatClient<Pick<WebSocketEventM
             this.options.connectingTimeoutMs ?? 10000
         );
         this.authenticated = false;
-        return new Promise((...args) => this.authenticatedResolvers = args);
+
+        return this.connectPromise;
     }
 
     public disconnect(): void {
-        this.sendQueue = [];
+        this.failPendingCommands(new Error('Client disconnected before the command was answered'));
         this.ws?.close(1000); // Normal closure
         this.ws = null;
     }
@@ -133,11 +145,11 @@ export class WebSocketChatClient extends AbstractChatClient<Pick<WebSocketEventM
             this.authenticated = isAuthenticated;
             if (isAuthenticated) {
                 this.startConnectionMonitor();
-                this.authenticatedResolvers[0]();
+                this.settleConnect();
                 this.emit(this.Event.connect);
                 this.sendFromQueue();
             } else {
-                this.authenticatedResolvers[1](envelope.data);
+                this.settleConnect(envelope.data);
             }
         }
     }
@@ -146,12 +158,54 @@ export class WebSocketChatClient extends AbstractChatClient<Pick<WebSocketEventM
         this.stopConnectionMonitor();
         clearTimeout(this.connectingTimeoutId);
         const reconnect = event.code !== 1000; // Connection was closed because of error
+
+        // The server can no longer answer anything that was queued or in
+        // flight, so settle those promises instead of leaving them pending.
+        this.failPendingCommands(new Error('Connection closed before the command was answered'));
+
         if (reconnect) {
+            // Keep a pending connect() promise unsettled - the retry below is
+            // expected to authenticate and will resolve it.
             void this.connect();
+        } else {
+            this.settleConnect(new Error('Connection closed before authentication'));
         }
+
         this.emit(this.Event.disconnect, reconnect);
     }
 
+    /**
+     * Resolve (or reject, when an error is given) a pending connect() promise.
+     * No-op when there is nothing pending.
+     */
+    private settleConnect(error?: any): void {
+        const resolvers = this.authenticatedResolvers;
+
+        this.authenticatedResolvers = null;
+        this.connectPromise = null;
+
+        if (! resolvers) {
+            return;
+        }
+
+        error ? resolvers[1](error) : resolvers[0]();
+    }
+
+    /**
+     * Reject every command that has not been answered yet - both the ones still
+     * waiting in the send queue and the ones already sent to the server.
+     */
+    private failPendingCommands(error: Error): void {
+        const queued = this.sendQueue;
+        this.sendQueue = [];
+
+        for (const envelope of queued) {
+            this.handleEnvelopeSendError(envelope, error);
+        }
+
+        this.failAwaitingResponses(error);
+    }
+
     private sendFromQueue(): void {
         // Send awaiting data to server
         let lastDelay = 0;
@@ -198,7 +252,9 @@ export class WebSocketChatClient extends AbstractChatClient<Pick<WebSocketEventM
                 this.ws.close(3000); // Service Restart (reconnect)
             }, this.options.ping.pongBackTimeoutMs);
 
-            this.send('Ping', {}).then(() => {
+            // A rejection here means the connection dropped while the ping was
+            // in flight; onClose already handles that, so just stop waiting.
+            this.send('Ping', {}).catch(() => undefined).then(() => {
                 clearTimeout(this.inFlightPingTimeout);
                 this.inFlightPingTimeout = undefined;
             });

package/src/state-tracker/AsyncUtils.ts

@@ -1,42 +1,53 @@
-import {IndexedCollection} from "../IndexedObjectCollection";
-
-export class DeferredTask {
-    public readonly promise: Promise<void>;
-    public resolve: () => void;
-
-    public constructor() {
-        this.promise = new Promise<void>((resolve) => this.resolve = resolve);
-    }
-}
-
-export class PromiseRegistry {
-    private promises = new IndexedCollection<string, Promise<any>>();
-
-    public register<T = any>(promise: Promise<T>, key: string): void {
-        this.promises.set([key, promise]);
-    }
-
-    public registerByFunction(fn: () => Promise<any>, key: string): void {
-        this.register(fn(), key);
-    }
-
-    public get<T = any>(key: string): Promise<T> | undefined {
-        return this.promises.get(key);
-    }
-
-    public has(key: string): boolean {
-        return this.promises.has(key);
-    }
-
-    public notExist(key: string): boolean {
-        return ! this.has(key);
-    }
-
-    public forget(...keys: string[]): void {
-        this.promises.delete(...keys);
-    }
-
-    public forgetAll(): void {
-        this.promises.deleteAll();
-    }
+import {IndexedCollection} from "../IndexedObjectCollection";
+
+export class DeferredTask {
+    public readonly promise: Promise<void>;
+    public resolve: () => void;
+
+    public constructor() {
+        this.promise = new Promise<void>((resolve) => this.resolve = resolve);
+    }
+}
+
+export class PromiseRegistry {
+    private promises = new IndexedCollection<string, Promise<any>>();
+
+    public register<T = any>(promise: Promise<T>, key: string): void {
+        this.promises.set([key, promise]);
+
+        // Never cache a failed lookup: drop it so the next access retries
+        // instead of replaying the same rejection forever (a request issued
+        // while the client was offline would otherwise poison the key). The
+        // handler also keeps the cached promise from surfacing as an unhandled
+        // rejection - callers still receive the rejection from their own await.
+        promise.catch(() => {
+            if (this.promises.get(key) === promise) {
+                this.promises.delete(key);
+            }
+        });
+    }
+
+    public registerByFunction(fn: () => Promise<any>, key: string): void {
+        this.register(fn(), key);
+    }
+
+    public get<T = any>(key: string): Promise<T> | undefined {
+        return this.promises.get(key);
+    }
+
+    public has(key: string): boolean {
+        return this.promises.has(key);
+    }
+
+    public notExist(key: string): boolean {
+        return ! this.has(key);
+    }
+
+    public forget(...keys: string[]): void {
+        this.promises.delete(...keys);
+    }
+
+    public forgetAll(): void {
+        this.promises.deleteAll();
+    }
 }

package/src/state-tracker/EmoticonsManager.ts

@@ -1,69 +1,73 @@
-import {ChatStateTracker} from "./ChatStateTracker";
-import {
-    IndexedCollection,
-    ObservableIndexedObjectCollection
-} from "../IndexedObjectCollection";
-import {Emoticon, EmoticonDeleted, Emoticons, NewEmoticon, SpaceDeleted} from "../types/src";
-import {PromiseRegistry} from "./AsyncUtils";
-
-const GLOBAL_KEY = 'global';
-
-export class EmoticonsManager {
-    private list: IndexedCollection<string, ObservableIndexedObjectCollection<Emoticon>> = new IndexedCollection();
-    private emoticonsPromises = new PromiseRegistry();
-    
-    public constructor(private tracker: ChatStateTracker) {
-        this.tracker.client.on('Emoticons', ev => this.handleEmoticons(ev));
-        this.tracker.client.on('NewEmoticon', ev => this.handleNewEmoticon(ev));
-        this.tracker.client.on('EmoticonDeleted', ev => this.handleEmoticonDeleted(ev));
-        this.tracker.client.on('SpaceDeleted', ev => this.handleSpaceDeleted(ev));
-        this.tracker.client.on('Session', () => this.handleSession());
-    }
-
-    public async get(spaceId?: string): Promise<ObservableIndexedObjectCollection<Emoticon>> {
-        const key = spaceId ?? GLOBAL_KEY;
-
-        if (this.emoticonsPromises.notExist(key)) {
-            this.emoticonsPromises.registerByFunction(async () => {
-                const result = await this.tracker.client.send('GetEmoticons', {spaceId});
-                if (result.error) {
-                    throw result.error;
-                }
-                this.handleEmoticons(result.data);
-            }, key);
-        }
-
-        await this.emoticonsPromises.get(key);
-        return this.list.get(key);
-    }
-
-    private handleEmoticons(event: Emoticons): void {
-        const spaceId = event.location.spaceId ?? GLOBAL_KEY;
-
-        if (!this.list.has(spaceId)) {
-            this.list.set([spaceId, new ObservableIndexedObjectCollection<Emoticon>('id')]);
-        }
-
-        const collection = this.list.get(spaceId);
-        collection.set(...event.emoticons);
-    }
-
-    private handleNewEmoticon(ev: NewEmoticon): void {
-        const collection = this.list.get(ev.emoticon.spaceId ?? GLOBAL_KEY);
-        collection?.set(ev.emoticon);
-    }
-
-    private handleEmoticonDeleted(ev: EmoticonDeleted): void {
-        const collection = this.list.get(ev.spaceId ?? GLOBAL_KEY);
-        collection?.delete(ev.emoticonId);
-    }
-
-    private handleSpaceDeleted(event: SpaceDeleted): void {
-        this.list.delete(event.id);
-    }
-
-    private handleSession(): void {
-        this.list.deleteAll();
-        this.emoticonsPromises.forgetAll();
-    }
+import {ChatStateTracker} from "./ChatStateTracker";
+import {
+    IndexedCollection,
+    ObservableIndexedObjectCollection
+} from "../IndexedObjectCollection";
+import {Emoticon, EmoticonDeleted, Emoticons, NewEmoticon, SpaceDeleted} from "../types/src";
+import {PromiseRegistry} from "./AsyncUtils";
+
+const GLOBAL_KEY = 'global';
+
+export class EmoticonsManager {
+    private list: IndexedCollection<string, ObservableIndexedObjectCollection<Emoticon>> = new IndexedCollection();
+    private emoticonsPromises = new PromiseRegistry();
+    
+    public constructor(private tracker: ChatStateTracker) {
+        this.tracker.client.on('Emoticons', ev => this.handleEmoticons(ev));
+        this.tracker.client.on('NewEmoticon', ev => this.handleNewEmoticon(ev));
+        this.tracker.client.on('EmoticonDeleted', ev => this.handleEmoticonDeleted(ev));
+        this.tracker.client.on('SpaceDeleted', ev => this.handleSpaceDeleted(ev));
+        this.tracker.client.on('Session', () => this.handleSession());
+    }
+
+    public async get(spaceId?: string): Promise<ObservableIndexedObjectCollection<Emoticon>> {
+        const key = spaceId ?? GLOBAL_KEY;
+
+        if (this.emoticonsPromises.notExist(key)) {
+            this.emoticonsPromises.registerByFunction(async () => {
+                const result = await this.tracker.client.send('GetEmoticons', {spaceId});
+                if (result.error) {
+                    throw result.error;
+                }
+                this.handleEmoticons(result.data);
+            }, key);
+        }
+
+        await this.emoticonsPromises.get(key);
+        return this.list.get(key);
+    }
+
+    private handleEmoticons(event: Emoticons): void {
+        const spaceId = event.location.spaceId ?? GLOBAL_KEY;
+
+        if (!this.list.has(spaceId)) {
+            this.list.set([spaceId, new ObservableIndexedObjectCollection<Emoticon>('id')]);
+        }
+
+        // handleEmoticons always carries the full list for a location, so
+        // reconcile in place: a reconnect refetch drops removed emoticons and
+        // adds new ones without blanking a bound (visible) collection.
+        this.list.get(spaceId).reconcile(...event.emoticons);
+    }
+
+    private handleNewEmoticon(ev: NewEmoticon): void {
+        const collection = this.list.get(ev.emoticon.spaceId ?? GLOBAL_KEY);
+        collection?.set(ev.emoticon);
+    }
+
+    private handleEmoticonDeleted(ev: EmoticonDeleted): void {
+        const collection = this.list.get(ev.spaceId ?? GLOBAL_KEY);
+        collection?.delete(ev.emoticonId);
+    }
+
+    private handleSpaceDeleted(event: SpaceDeleted): void {
+        this.list.delete(event.id);
+    }
+
+    private handleSession(): void {
+        // Keep cached emoticon collections (they may be bound to visible
+        // pickers); just drop the fetch guards so the next access refetches and
+        // reconciles them in place.
+        this.emoticonsPromises.forgetAll();
+    }
 }