polfan-server-js-client 0.1.997 → 0.1.999

package/build/types/WebSocketChatClient.d.ts

@@ -1,6 +1,7 @@
 import { ObservableInterface } from "./EventTarget";
 import { AbstractChatClient, CommandResult, CommandsMap } from "./AbstractChatClient";
 import { ChatStateTracker } from "./state-tracker/ChatStateTracker";
+import { Envelope } from "./types/src";
 export interface WebSocketClientOptions {
     url: string;
     token?: string;
@@ -20,7 +21,7 @@ export declare class WebSocketChatClient extends AbstractChatClient implements O
     readonly Event: typeof WebSocketChatClientEvent;
     readonly state?: ChatStateTracker;
     protected ws: WebSocket | null;
-    protected sendQueue: [commandType: keyof CommandsMap, commandData: any][];
+    protected sendQueue: Envelope[];
     protected connectingTimeoutId: any;
     protected authenticated: boolean;
     protected authenticatedResolvers: [() => void, (error: Error) => void];
@@ -28,6 +29,7 @@ export declare class WebSocketChatClient extends AbstractChatClient implements O
     connect(): Promise<void>;
     disconnect(): void;
     send<CommandType extends keyof CommandsMap>(commandType: CommandType, commandData: CommandsMap[CommandType][0]): Promise<CommandResult<CommandsMap[CommandType][1]>>;
+    private sendEnvelope;
     private onMessage;
     private onClose;
     private sendFromQueue;

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

@@ -33,6 +33,9 @@ export declare abstract class TraversableRemoteCollection<T> extends ObservableI
     limit: number | null;
     private currentState;
     private fetchingState;
+    oldestId: string;
+    get hasLatest(): boolean;
+    get hasOldest(): boolean;
     resetToLatest(): Promise<void>;
     fetchPrevious(): Promise<void>;
     fetchNext(): Promise<void>;
@@ -42,7 +45,6 @@ export declare abstract class TraversableRemoteCollection<T> extends ObservableI
     protected abstract isLatestItemLoaded(): Promise<boolean>;
     protected refreshFetchedState(): Promise<void>;
     protected addItems(newItems: T[], to: 'head' | 'tail'): void;
-    private throwIfFetchingInProgress;
     /**
      * Return array with messages of count that matching limit.
      */

package/package.json

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

package/src/WebSocketChatClient.ts

@@ -24,7 +24,7 @@ export class WebSocketChatClient extends AbstractChatClient implements Observabl
     public readonly state?: ChatStateTracker;
 
     protected ws: WebSocket|null = null;
-    protected sendQueue: [commandType: keyof CommandsMap, commandData: any][] = [];
+    protected sendQueue: Envelope[] = [];
     protected connectingTimeoutId: any;
     protected authenticated: boolean;
     protected authenticatedResolvers: [() => void, (error: Error) => void];
@@ -64,18 +64,24 @@ export class WebSocketChatClient extends AbstractChatClient implements Observabl
             throw new Error('Cannot send; close or closing connection state');
         }
 
+        const envelope = this.createEnvelope<CommandsMap[CommandType][0]>(commandType, commandData);
+        const promise = this.createPromiseFromCommandEnvelope<CommandType>(envelope);
+
         if (this.ws.readyState === this.ws.CONNECTING || !this.authenticated) {
-            this.sendQueue.push([commandType, commandData] as any);
-            return;
+            this.sendQueue.push(envelope);
+            return promise;
         }
 
         if (this.ws.readyState !== this.ws.OPEN) {
             throw new Error(`Invalid websocket state=${this.ws.readyState}`);
         }
 
-        const envelope = this.createEnvelope<CommandsMap[CommandType][0]>(commandType, commandData);
+        this.sendEnvelope(envelope);
+        return promise;
+    }
+
+    private sendEnvelope(envelope: Envelope): void {
         this.ws.send(JSON.stringify(envelope));
-        return this.createPromiseFromCommandEnvelope<CommandType>(envelope);
     }
 
     private onMessage(event: MessageEvent): void {
@@ -111,8 +117,8 @@ export class WebSocketChatClient extends AbstractChatClient implements Observabl
         // Send awaiting data to server
         let lastDelay = 0;
         for (const dataIndex in this.sendQueue) {
-            const data = this.sendQueue[dataIndex];
-            setTimeout(() => this.send(...data), lastDelay);
+            const envelope = this.sendQueue[dataIndex];
+            setTimeout(() => this.sendEnvelope(envelope), lastDelay);
             lastDelay += this.options.awaitQueueSendDelayMs ?? 500;
         }
         this.sendQueue = [];

package/src/state-tracker/TopicHistoryWindow.ts

@@ -42,11 +42,18 @@ export abstract class TraversableRemoteCollection<T> extends ObservableIndexedOb
 
     private currentState: WindowState = WindowState.LIVE;
     private fetchingState: WindowState = undefined;
+    public oldestId: string = null;
 
-    public async resetToLatest(): Promise<void> {
-        this.throwIfFetchingInProgress();
+    public get hasLatest(): boolean {
+        return [WindowState.LATEST, WindowState.LIVE].includes(this.state);
+    }
+
+    public get hasOldest(): boolean {
+        return this.state === WindowState.OLDEST || this.oldestId !== null && this.has(this.oldestId);
+    }
 
-        if (this.currentState === WindowState.LATEST) {
+    public async resetToLatest(): Promise<void> {
+        if (this.fetchingState || this.currentState === WindowState.LATEST) {
             return;
         }
 
@@ -66,12 +73,10 @@ export abstract class TraversableRemoteCollection<T> extends ObservableIndexedOb
     }
 
     public async fetchPrevious(): Promise<void> {
-        if (this.state === WindowState.OLDEST) {
+        if (this.fetchingState || this.hasOldest) {
             return;
         }
 
-        this.throwIfFetchingInProgress();
-
         this.fetchingState = WindowState.PAST;
 
         let result;
@@ -87,7 +92,17 @@ export abstract class TraversableRemoteCollection<T> extends ObservableIndexedOb
         }
 
         if (! result.length) {
-            this.currentState = WindowState.OLDEST;
+            const firstItem = this.getAt(0);
+            console.log(firstItem)
+            this.oldestId = firstItem ? this.getId(firstItem) : null;
+
+            await this.refreshFetchedState();
+
+            // LATEST state has priority over OLDEST
+            if (this.currentState === WindowState.PAST) {
+                this.currentState = WindowState.OLDEST;
+            }
+
             return;
         }
 
@@ -96,7 +111,9 @@ export abstract class TraversableRemoteCollection<T> extends ObservableIndexedOb
     }
 
     public async fetchNext(): Promise<void> {
-        this.throwIfFetchingInProgress();
+        if (this.fetchingState || this.hasLatest) {
+            return;
+        }
 
         this.fetchingState = WindowState.PAST;
 
@@ -116,6 +133,7 @@ export abstract class TraversableRemoteCollection<T> extends ObservableIndexedOb
         if (result.length) {
             this.addItems(result, 'tail');
             await this.refreshFetchedState();
+            return;
         }
     }
 
@@ -146,12 +164,6 @@ export abstract class TraversableRemoteCollection<T> extends ObservableIndexedOb
         this.set(...result);
     }
 
-    private throwIfFetchingInProgress(): void {
-        if (this.fetchingState) {
-            throw new Error(`Items fetching in progress: ${WindowState[this.fetchingState]}`);
-        }
-    }
-
     /**
      * Return array with messages of count that matching limit.
      */

package/tests/history-window.test.ts

@@ -122,10 +122,16 @@ test('history window - traverse forward', async () => {
     const window = new TestableHistoryWindow();
     window.limit = 5;
 
-    await window.fetchNext(); // [7,8,9]
+    await window.fetchNext(); // []
+
+    expect(window.state).toEqual(WindowState.LIVE);
+    expect(window.items).toHaveLength(0);
+
+    await window.resetToLatest(); // [7,8,9]
 
     expect(window.state).toEqual(WindowState.LATEST);
     expect(window.items).toHaveLength(3);
+
     [7,8,9].forEach(id => expect(window.items.map(item => item.id)).toContain(id));
 
     await window.fetchPrevious(); // [4,5,6,7,8]
@@ -188,4 +194,25 @@ test('history window - trim messages window to limit', async () => {
     window.simulateNewMessageReceived();
 
     expect(window.items).toHaveLength(5);
+});
+
+test('history window - states priority', async () => {
+    const window = new TestableHistoryWindow();
+    window.limit = 10;
+
+    await window.resetToLatest(); // [7,8,9]
+
+    expect(window.state).toEqual(WindowState.LATEST);
+
+    await window.fetchPrevious(); // [4,5,6,7,8,9]
+    await window.fetchPrevious(); // [1,2,3,4,5,6,7,8,9]
+    await window.fetchPrevious(); // [0,1,2,3,4,5,6,7,8,9]
+
+    expect(window.state).toEqual(WindowState.LATEST);
+    expect(window.hasOldest).toBeFalsy();
+    expect(window.hasLatest).toBeTruthy();
+
+    await window.fetchPrevious();
+
+    expect(window.hasOldest).toBeTruthy();
 });