polfan-server-js-client 0.2.106 → 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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polfan-server-js-client",
-  "version": "0.2.106",
+  "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/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/RoomMessagesHistory.ts

@@ -59,16 +59,22 @@ export class RoomMessagesHistory {
         }
 
         for (const [, window] of Array.from(this.historyWindows.items)) {
-            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;
-            }
+            try {
+                await window.setTraverseLock(this.traverseLock);
 
-            if (window.state === WindowState.LATEST) {
-                await window.resetToLatest(true);
+                // 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.
             }
         }
     }

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]);
+    });
+})