polfan-server-js-client 0.2.102 → 0.2.103

package/build/types/WebApiChatClient.d.ts

@@ -18,19 +18,21 @@ type WebApiEventMap = EventsMap & {
     [WebApiChatClientEvent.error]: Error;
     [WebApiChatClientEvent.destroy]: boolean;
 };
+interface SendStackItem {
+    data: Envelope;
+    attempts: number;
+    lastTimeoutId: any;
+}
 export declare class WebApiChatClient extends AbstractChatClient<Pick<WebApiEventMap, keyof WebApiEventMap>> implements ObservableInterface {
     private readonly options;
     readonly Event: typeof WebApiChatClientEvent;
-    protected sendStack: {
-        data: any;
-        attempts: number;
-        lastTimeoutId: any;
-    }[];
+    protected sendStack: SendStackItem[];
     constructor(options: WebApiChatClientOptions);
     send<CommandType extends keyof CommandsMap>(commandType: CommandType, commandData: CommandRequest<CommandType>): Promise<CommandResult<CommandResponse<CommandType>>>;
     destroy(): void;
-    protected onMessage(reqId: number, response: Response): Promise<void>;
-    protected onError(reqId: number, body: string): void;
-    protected makeApiCall(reqId: number): void;
+    protected onMessage(item: SendStackItem, response: Response): Promise<void>;
+    protected onError(item: SendStackItem, body: string): void;
+    protected makeApiCall(item: SendStackItem): void;
+    private removeFromStack;
 }
 export {};

package/package.json

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

package/src/WebApiChatClient.ts

@@ -22,10 +22,16 @@ type WebApiEventMap = EventsMap & {
     [WebApiChatClientEvent.destroy]: boolean;
 };
 
+interface SendStackItem {
+    data: Envelope;
+    attempts: number;
+    lastTimeoutId: any;
+}
+
 export class WebApiChatClient extends AbstractChatClient<Pick<WebApiEventMap, keyof WebApiEventMap>> implements ObservableInterface {
     public readonly Event = WebApiChatClientEvent;
 
-    protected sendStack: {data: any, attempts: number, lastTimeoutId: any}[];
+    protected sendStack: SendStackItem[] = [];
 
     public constructor(private readonly options: WebApiChatClientOptions) {
         super();
@@ -34,48 +40,72 @@ export class WebApiChatClient extends AbstractChatClient<Pick<WebApiEventMap, ke
     public async send<CommandType extends keyof CommandsMap>(commandType: CommandType, commandData: CommandRequest<CommandType>):
         Promise<CommandResult<CommandResponse<CommandType>>> {
         const envelope = this.createEnvelope(commandType, commandData);
-        this.sendStack.push({data: envelope, attempts: 0, lastTimeoutId: null});
-        this.makeApiCall(this.sendStack.length - 1);
+        const item: SendStackItem = {data: envelope, attempts: 0, lastTimeoutId: null};
+        this.sendStack.push(item);
+        this.makeApiCall(item);
         return this.createPromiseFromCommandEnvelope(envelope);
     }
 
     public destroy(): void {
-        // Cancel all awaiting requests
-        this.sendStack.forEach(item => {
+        // Cancel all awaiting requests, rejecting their promises so no caller
+        // is left awaiting forever
+        const pending = this.sendStack;
+        this.sendStack = [];
+        pending.forEach(item => {
             if (item.lastTimeoutId) {
                 clearTimeout(item.lastTimeoutId);
             }
-            this.awaitingResponse.delete(item.data.ref);
+            this.handleEnvelopeSendError(item.data, new Error('Client destroyed'));
         });
-        this.sendStack = [];
         this.emit(this.Event.destroy, false);
     }
 
-    protected async onMessage(reqId: number, response: Response): Promise<void> {
-        this.sendStack.splice(reqId, 1);
-        const envelope: Envelope = await response.json();
+    protected async onMessage(item: SendStackItem, response: Response): Promise<void> {
+        let envelope: Envelope;
+        try {
+            envelope = await response.json();
+        } catch (e) {
+            // Non-envelope response (e.g. a proxy error page) - failed attempt
+            this.onError(item, `envelope ${item.data.ref} (HTTP ${response.status}, unparsable body)`);
+            return;
+        }
+
+        if (!this.removeFromStack(item)) {
+            return; // Destroyed in the meantime - the promise is already rejected
+        }
+
         this.handleIncomingEnvelope(envelope);
         this.emit(envelope.type, envelope.data);
         this.emit(this.Event.message, envelope);
     }
 
-    protected onError(reqId: number, body: string): void {
-        if (this.sendStack[reqId].attempts >= (this.options.attemptsToSend ?? 10)) {
-            this.sendStack.splice(reqId, 1);
-            this.handleEnvelopeSendError(this.sendStack[reqId].data, new Error(
+    protected onError(item: SendStackItem, body: string): void {
+        if (!this.sendStack.includes(item)) {
+            return; // Destroyed in the meantime
+        }
+
+        if (item.attempts >= (this.options.attemptsToSend ?? 10)) {
+            this.removeFromStack(item);
+            this.handleEnvelopeSendError(item.data, new Error(
                 `Cannot send ${body}; aborting after reaching the maximum connection errors`
             ));
             return;
         }
-        this.sendStack[reqId].lastTimeoutId = setTimeout(
-            () => this.makeApiCall(reqId),
+
+        item.lastTimeoutId = setTimeout(
+            () => this.makeApiCall(item),
             this.options.attemptDelayMs ?? 3000
         );
     }
 
-    protected makeApiCall(reqId: number): void {
-        this.sendStack[reqId].attempts++;
-        const bodyJson = JSON.stringify(this.sendStack[reqId].data);
+    protected makeApiCall(item: SendStackItem): void {
+        if (!this.sendStack.includes(item)) {
+            return; // Destroyed before this (re)try fired
+        }
+
+        item.attempts++;
+        item.lastTimeoutId = null;
+        const bodyJson = JSON.stringify(item.data);
         const headers: any = {
             'Content-Type': 'application/json',
             Accept: 'application/json'
@@ -83,15 +113,24 @@ export class WebApiChatClient extends AbstractChatClient<Pick<WebApiEventMap, ke
 
         headers.Authorization = `Bearer ${this.options.token}`;
 
-        const params = new URLSearchParams(this.options.queryParams ?? {});
-        const url = `${this.options.url}${params ? '?' + params : ''}`;
+        const query = new URLSearchParams(this.options.queryParams ?? {}).toString();
+        const url = query ? `${this.options.url}?${query}` : this.options.url;
 
         fetch(url, {
             headers,
             body: bodyJson,
             method: 'POST',
         })
-            .then(response => this.onMessage(reqId, response))
-            .catch(() => this.onError(reqId, bodyJson));
+            .then(response => this.onMessage(item, response))
+            .catch(() => this.onError(item, bodyJson));
+    }
+
+    private removeFromStack(item: SendStackItem): boolean {
+        const index = this.sendStack.indexOf(item);
+        if (index === -1) {
+            return false;
+        }
+        this.sendStack.splice(index, 1);
+        return true;
     }
 }