polfan-server-js-client 0.1.994 → 0.1.996

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

@@ -2,9 +2,24 @@ import { Message, MessageReference } from "../types/src";
 import { ChatStateTracker } from "./ChatStateTracker";
 import { ObservableIndexedObjectCollection } from "../IndexedObjectCollection";
 export declare enum WindowState {
-    UNINITIALIZED = 0,
+    /**
+     * The latest messages (those received live) are available in the history window, history has not been fetched.
+     */
+    LIVE = 0,
+    /**
+     * The latest messages has been fetched and are available in the history window.
+     */
     LATEST = 1,
-    PAST = 2
+    /**
+     * The historical messages have been fetched and are available in the history window.
+     * Latest messages are not available and will not be available.
+     */
+    PAST = 2,
+    /**
+     * The oldest messages have been fetched and are available in the history window.
+     * Next attempts to fetch previous messages will result with no-op.
+     */
+    OLDEST = 3
 }
 export declare abstract class TraversableRemoteCollection<T> extends ObservableIndexedObjectCollection<T> {
     /**
@@ -25,9 +40,9 @@ export declare abstract class TraversableRemoteCollection<T> extends ObservableI
     protected abstract fetchItemsBefore(): Promise<T[] | null>;
     protected abstract fetchItemsAfter(): Promise<T[] | null>;
     protected abstract isLatestItemLoaded(): Promise<boolean>;
-    protected refreshMode(): Promise<void>;
+    protected refreshFetchedState(): Promise<void>;
+    protected addItems(newItems: T[], to: 'head' | 'tail'): void;
     private throwIfFetchingInProgress;
-    private addItems;
     /**
      * Return array with messages of count that matching limit.
      */

package/package.json

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

package/src/state-tracker/TopicHistoryWindow.ts

@@ -1,11 +1,29 @@
-import {Message, MessageReference, NewMessage, Room, Session, Topic} from "../types/src";
+import {Message, MessageReference, NewMessage, Session, Topic} from "../types/src";
 import {ChatStateTracker} from "./ChatStateTracker";
 import {ObservableIndexedObjectCollection} from "../IndexedObjectCollection";
 
 export enum WindowState {
-    UNINITIALIZED,
+    /**
+     * The latest messages (those received live) are available in the history window, history has not been fetched.
+     */
+    LIVE,
+
+    /**
+     * The latest messages has been fetched and are available in the history window.
+     */
     LATEST,
+
+    /**
+     * The historical messages have been fetched and are available in the history window.
+     * Latest messages are not available and will not be available.
+     */
     PAST,
+
+    /**
+     * The oldest messages have been fetched and are available in the history window.
+     * Next attempts to fetch previous messages will result with no-op.
+     */
+    OLDEST,
 }
 
 export abstract class TraversableRemoteCollection<T> extends ObservableIndexedObjectCollection<T> {
@@ -22,7 +40,7 @@ export abstract class TraversableRemoteCollection<T> extends ObservableIndexedOb
      */
     public limit: number | null = 50;
 
-    private currentState: WindowState = WindowState.UNINITIALIZED;
+    private currentState: WindowState = WindowState.LIVE;
     private fetchingState: WindowState = undefined;
 
     public async resetToLatest(): Promise<void> {
@@ -48,6 +66,10 @@ export abstract class TraversableRemoteCollection<T> extends ObservableIndexedOb
     }
 
     public async fetchPrevious(): Promise<void> {
+        if (this.state === WindowState.OLDEST) {
+            return;
+        }
+
         this.throwIfFetchingInProgress();
 
         this.fetchingState = WindowState.PAST;
@@ -61,18 +83,23 @@ export abstract class TraversableRemoteCollection<T> extends ObservableIndexedOb
         }
 
         if (! result) {
-            return  this.resetToLatest();
+            return this.resetToLatest();
         }
 
-        if (result.length) {
-            this.addItems(result, 'head');
-            this.currentState = (await this.isLatestItemLoaded()) ? WindowState.LATEST : WindowState.PAST;
+        if (! result.length) {
+            this.currentState = WindowState.OLDEST;
+            return;
         }
+
+        this.addItems(result, 'head');
+        await this.refreshFetchedState();
     }
 
     public async fetchNext(): Promise<void> {
         this.throwIfFetchingInProgress();
 
+        this.fetchingState = WindowState.PAST;
+
         let result;
 
         try {
@@ -88,7 +115,7 @@ export abstract class TraversableRemoteCollection<T> extends ObservableIndexedOb
 
         if (result.length) {
             this.addItems(result, 'tail');
-            await this.refreshMode();
+            await this.refreshFetchedState();
         }
     }
 
@@ -100,17 +127,11 @@ export abstract class TraversableRemoteCollection<T> extends ObservableIndexedOb
 
     protected abstract isLatestItemLoaded(): Promise<boolean>;
 
-    protected async refreshMode(): Promise<void> {
+    protected async refreshFetchedState(): Promise<void> {
         this.currentState = (await this.isLatestItemLoaded()) ? WindowState.LATEST : WindowState.PAST;
     }
 
-    private throwIfFetchingInProgress(): void {
-        if (this.fetchingState) {
-            throw new Error(`Items fetching in progress: ${WindowState[this.fetchingState]}`);
-        }
-    }
-
-    private addItems(newItems: T[], to: 'head' | 'tail'): void {
+    protected addItems(newItems: T[], to: 'head' | 'tail'): void {
         let result;
 
         if (to === 'head') {
@@ -125,6 +146,12 @@ 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.
      */
@@ -174,15 +201,11 @@ export class TopicHistoryWindow extends TraversableRemoteCollection<Message> {
 
     private async handleNewMessage(ev: NewMessage): Promise<void> {
         if (
-            [WindowState.LATEST, WindowState.UNINITIALIZED].includes(this.state)
+            [WindowState.LATEST, WindowState.LIVE].includes(this.state)
             && ev.location.roomId === this.roomId
             && ev.location.topicId === this.topicId
         ) {
-            this.set(ev.message);
-
-            if (this.state === WindowState.UNINITIALIZED) {
-                await this.refreshMode();
-            }
+            this.addItems([ev.message], 'tail');
         }
     }
 
@@ -252,6 +275,6 @@ export class TopicHistoryWindow extends TraversableRemoteCollection<Message> {
 
     protected async isLatestItemLoaded(): Promise<boolean> {
         const lastMessageId = await this.getLatestMessageId();
-        return lastMessageId ? this.has(lastMessageId) : false;
+        return lastMessageId ? this.has(lastMessageId) : true;
     }
 }

package/tests/history-window.test.ts

@@ -22,6 +22,20 @@ class TestableHistoryWindow extends TraversableRemoteCollection<SimpleMessage> {
         super('id');
     }
 
+    public simulateNewMessageReceived(): void {
+        if ([WindowState.LATEST, WindowState.LIVE].includes(this.state)) {
+            const lastId = this.getAt(this.length - 1)?.id;
+
+            const messageToAdd = lastId
+                ? this.getAt(lastId + 1)
+                : messages[messages.length - 1];
+
+            if (messageToAdd) {
+                this.addItems([messageToAdd], 'tail');
+            }
+        }
+    }
+
     protected async fetchItemsAfter(): Promise<SimpleMessage[]> {
         const after = this.getAt(this.length - 1)?.id;
         if (after === undefined) {
@@ -52,7 +66,31 @@ test('history window - fresh instance', async () => {
     const window = new TestableHistoryWindow();
     expect(window.items).toHaveLength(0);
     expect(window.limit).toEqual(50);
-    expect(window.state).toEqual(WindowState.UNINITIALIZED);
+});
+
+test('history window - states change', async () => {
+    const window = new TestableHistoryWindow();
+    window.limit = 5;
+
+    expect(window.state).toEqual(WindowState.LIVE);
+
+    window.simulateNewMessageReceived(); // [9]
+
+    expect(window.state).toEqual(WindowState.LIVE);
+
+    await window.fetchPrevious(); // [6,7,8,9]
+    await window.fetchPrevious(); // [3,4,5,6,7]
+
+    expect(window.state).toEqual(WindowState.PAST);
+
+    await window.fetchPrevious(); // [0,1,2,3,4]
+    await window.fetchPrevious(); // [0,1,2,3,4]
+
+    expect(window.state).toEqual(WindowState.OLDEST);
+
+    await window.resetToLatest(); // [7,8,9]
+
+    expect(window.state).toEqual(WindowState.LATEST);
 });
 
 test('history window - traverse back', async () => {
@@ -75,7 +113,7 @@ test('history window - traverse back', async () => {
     await window.fetchPrevious(); // 0,1,2,3,4
     await window.fetchPrevious(); // 0,1,2,3,4
 
-    expect(window.state).toEqual(WindowState.PAST);
+    expect(window.state).toEqual(WindowState.OLDEST);
     expect(window.items).toHaveLength(5);
     [0,1,2,3,4].forEach(id => expect(window.items.map(item => item.id)).toContain(id));
 });
@@ -84,7 +122,7 @@ test('history window - traverse forward', async () => {
     const window = new TestableHistoryWindow();
     window.limit = 5;
 
-    await window.fetchNext();
+    await window.fetchNext(); // [7,8,9]
 
     expect(window.state).toEqual(WindowState.LATEST);
     expect(window.items).toHaveLength(3);
@@ -111,13 +149,9 @@ test('history window - reset to latest', async () => {
     const window = new TestableHistoryWindow();
     window.limit = 5;
 
-    await window.fetchPrevious();
-
-    expect(window.state).toEqual(WindowState.LATEST);
-
-    await window.fetchPrevious();
-    await window.fetchPrevious();
-    await window.fetchPrevious(); // Move to start
+    await window.fetchPrevious(); // [7,8,9]
+    await window.fetchPrevious(); // [4,5,6,7,8]
+    await window.fetchPrevious(); // [1,2,3,4,5]
 
     expect(window.state).toEqual(WindowState.PAST);
 
@@ -127,3 +161,31 @@ test('history window - reset to latest', async () => {
     expect(window.items).toHaveLength(3);
     [7,8,9].forEach(id => expect(window.items.map(item => item.id)).toContain(id));
 });
+
+test('history window - trim messages window to limit', async () => {
+    const window = new TestableHistoryWindow();
+    window.limit = 5;
+
+    expect(window.items).toHaveLength(0);
+
+    await window.fetchPrevious(); // [7,8,9]
+
+    expect(window.items).toHaveLength(3);
+
+    await window.fetchPrevious(); // [4,5,6,7,8]
+
+    expect(window.items).toHaveLength(5);
+
+    await window.fetchNext(); // [5,6,7,8,9]
+
+    expect(window.items).toHaveLength(5);
+
+    await window.fetchPrevious(); // [2,3,4,5,6]
+
+    expect(window.items).toHaveLength(5);
+
+    window.simulateNewMessageReceived();
+    window.simulateNewMessageReceived();
+
+    expect(window.items).toHaveLength(5);
+});