polfan-server-js-client 0.1.0 → 0.1.2

package/src/AuthClient.ts

@@ -0,0 +1,46 @@
+import {AbstractRestClient} from "./AbstractRestClient";
+
+export interface TokenInterface {
+    token: string,
+    expiration: string
+}
+
+export interface MyAccountInterface {
+    id: string;
+    nick: string;
+    avatar: string;
+}
+
+export class AuthClient extends AbstractRestClient {
+    protected defaultUrl: string = 'https://polfan.pl/webservice/api';
+
+    public static async createToken(
+        login: string,
+        password: string,
+        clientName: string = 'pserv-js-client'
+    ): Promise<TokenInterface> {
+        const response = await new AuthClient({token: null}).send('POST', 'auth/tokens', {
+            login, password, client_name: clientName
+        });
+        if (response.ok) {
+            return response.data;
+        }
+        throw new Error(`Cannot create user token: ${response.data.errors[0]}`);
+    }
+
+    public async deleteToken(token: string): Promise<void> {
+        const response = await this.send('DELETE', `auth/tokens/${token}`);
+        if (!response.ok) {
+            throw new Error(`Cannot delete access token: ${response.data.errors[0]}`);
+        }
+    }
+
+    public async getMe(): Promise<MyAccountInterface> {
+        const response = await this.send('GET', 'auth/me');
+        if (response.ok) {
+            response.data.id = response.data.id.toString();
+            return response.data;
+        }
+        throw new Error(`Cannot get current user account: ${response.data.errors[0]}`);
+    }
+}

package/src/{WebSocketStateTracker.ts → ChatStateTracker.ts}

@@ -1,4 +1,4 @@
-import {WebSocketClient} from "./WebSocketClient";
+import {WebSocketChatClient} from "./WebSocketChatClient";
 import {IndexedCollection, ObservableIndexedObjectCollection} from "./IndexedObjectCollection";
 import {
     Message,
@@ -29,7 +29,7 @@ import {
 
 type Deferred = {resolver: () => void, promise: Promise<void>};
 
-export class WebSocketStateTracker {
+export class ChatStateTracker {
     private readonly joinedSpaces = new ObservableIndexedObjectCollection<Space>('id');
     private readonly joinedRooms = new ObservableIndexedObjectCollection<Room>('id');
     private readonly spacesRoles = new IndexedCollection<string, ObservableIndexedObjectCollection<Role>>();
@@ -46,7 +46,8 @@ export class WebSocketStateTracker {
     private reconnecting: boolean = false;
     private me: User = null;
 
-    public constructor(private readonly client: WebSocketClient) {
+    public constructor(private readonly client: WebSocketChatClient) {
+        this.createDeferredGetter('session');
         this.bind();
     }
 
@@ -200,6 +201,16 @@ export class WebSocketStateTracker {
             room.id,
             new ObservableIndexedObjectCollection<Topic>('id', room.topics)
         ]));
+
+        const topicsMessages: [string, ObservableIndexedObjectCollection<Message>][] = [];
+        for (const room of rooms) {
+            topicsMessages.push(...room.topics.map<[string, ObservableIndexedObjectCollection<Message>]>(topic => [
+                topic.id,
+                new ObservableIndexedObjectCollection<Message>('id')
+            ]));
+        }
+        this.topicsMessages.set(...topicsMessages);
+
         this.joinedRooms.set(...rooms);
     }
 
@@ -235,12 +246,11 @@ export class WebSocketStateTracker {
     }
 
     private handleSession(ev: Session): void {
-        this.me = ev.user;
-
         if (this.me && !this.reconnecting) {
             return;
         }
 
+        this.me = ev.user;
         this.reconnecting = false;
 
         this.joinedRooms.deleteAll();

package/src/EventTarget.ts

@@ -4,6 +4,7 @@ type HandlersMap<EventT> = Map<string, EventHandler<EventT>[]>;
 export interface ObservableInterface<EventT = any> {
     on(eventName: string, handler: EventHandler<EventT>): this;
     once(eventName: string, handler: EventHandler<EventT>): this;
+    off(eventName: string, handler: EventHandler<EventT>): this;
 }
 
 export class EventTarget<EventT = any> implements ObservableInterface<EventT> {
@@ -20,6 +21,14 @@ export class EventTarget<EventT = any> implements ObservableInterface<EventT> {
         return this;
     }
 
+    public off(eventName: string, handler: EventHandler<EventT>): this {
+        const index = this.events.get(eventName)?.indexOf(handler);
+        if (!index || index < 0) {
+            return this;
+        }
+        this.events.get(eventName).splice(index, 1);
+    }
+
     public emit(eventName: string, event?: EventT): this {
         this.callHandlers(this.events, eventName, event);
         this.callHandlers(this.onceEvents, eventName, event);

package/src/IndexedObjectCollection.ts

@@ -131,6 +131,12 @@ interface ObservableCollectionEvent<KeyT> {
 export class ObservableIndexedCollection<KeyT, ValueT> extends IndexedCollection<KeyT, ValueT> implements ObservableInterface {
     protected eventTarget: EventTarget<ObservableCollectionEvent<KeyT>>;
 
+    public constructor(items: [key: KeyT, value: ValueT][] = []) {
+        super();
+        this.eventTarget = new EventTarget<ObservableCollectionEvent<KeyT>>();
+        this.set(...items);
+    }
+
     public set(...items: [KeyT, ValueT][]) {
         if (items.length) {
             super.set(...items);
@@ -162,6 +168,11 @@ export class ObservableIndexedCollection<KeyT, ValueT> extends IndexedCollection
         this.eventTarget.once(eventName, handler);
         return this;
     }
+
+    public off(eventName: string, handler: (ev?: ObservableCollectionEvent<KeyT>) => void): this {
+        this.eventTarget.off(eventName, handler);
+        return this;
+    }
 }
 
 export class ObservableIndexedObjectCollection<T> extends IndexedObjectCollection<T> implements ObservableInterface {
@@ -171,8 +182,9 @@ export class ObservableIndexedObjectCollection<T> extends IndexedObjectCollectio
         public readonly id: keyof T | ((item: T) => string),
         items: T[] = [],
     ) {
-        super(id, items);
+        super(id);
         this.eventTarget = new EventTarget();
+        this.set(...items);
     }
 
     public set(...items: T[]) {
@@ -206,4 +218,9 @@ export class ObservableIndexedObjectCollection<T> extends IndexedObjectCollectio
         this.eventTarget.once(eventName, handler);
         return this;
     }
+
+    public off(eventName: string, handler: (ev?: ObservableCollectionEvent<string>) => void): this {
+        this.eventTarget.off(eventName, handler);
+        return this;
+    }
 }

package/src/{WebApiClient.ts → WebApiChatClient.ts}

@@ -1,8 +1,8 @@
-import {AbstractClient, CommandResult, CommandsMap} from "./AbstractClient";
+import {AbstractChatClient, CommandResult, CommandsMap} from "./AbstractChatClient";
 import {ObservableInterface} from "./EventTarget";
 import {Envelope} from "pserv-ts-types";
 
-export interface WebApiClientOptions {
+export interface WebApiChatClientOptions {
     url: string;
     token?: string;
     temporaryNick?: string;
@@ -10,18 +10,18 @@ export interface WebApiClientOptions {
     attemptDelayMs?: number;
 }
 
-enum WebApiClientEvent {
+enum WebApiChatClientEvent {
     message = 'message',
     error = 'error',
     destroy = 'destroy',
 }
 
-export class WebApiClient extends AbstractClient implements ObservableInterface {
-    public readonly Event = WebApiClientEvent;
+export class WebApiChatClient extends AbstractChatClient implements ObservableInterface {
+    public readonly Event = WebApiChatClientEvent;
 
     protected sendStack: {data: any, attempts: number, lastTimeoutId: any}[];
 
-    public constructor(private readonly options: WebApiClientOptions) {
+    public constructor(private readonly options: WebApiChatClientOptions) {
         super();
         if (!this.options.token && !this.options.temporaryNick) {
             throw new Error('Token or temporary nick is required');
@@ -52,7 +52,7 @@ export class WebApiClient extends AbstractClient implements ObservableInterface
         this.sendStack.splice(reqId, 1);
         const envelope: Envelope = await response.json();
         this.handleIncomingEnvelope(envelope);
-        this.emit(envelope.type, envelope);
+        this.emit(envelope.type, envelope.data);
         this.emit(this.Event.message, envelope);
     }
 

package/src/{WebSocketClient.ts → WebSocketChatClient.ts}

@@ -1,7 +1,7 @@
 import {ObservableInterface} from "./EventTarget";
-import {AbstractClient, CommandResult, CommandsMap} from "./AbstractClient";
+import {AbstractChatClient, CommandResult, CommandsMap} from "./AbstractChatClient";
 import {Envelope} from "pserv-ts-types";
-import {WebSocketStateTracker} from "./WebSocketStateTracker";
+import {ChatStateTracker} from "./ChatStateTracker";
 
 export interface WebSocketClientOptions {
     url: string;
@@ -12,16 +12,16 @@ export interface WebSocketClientOptions {
     stateTracking?: boolean;
 }
 
-enum WebSocketClientEvent {
+enum WebSocketChatClientEvent {
     connect = 'connect',
     disconnect = 'disconnect',
     message = 'message',
     error = 'error',
 }
 
-export class WebSocketClient extends AbstractClient implements ObservableInterface {
-    public readonly Event = WebSocketClientEvent;
-    public readonly state?: WebSocketStateTracker;
+export class WebSocketChatClient extends AbstractChatClient implements ObservableInterface {
+    public readonly Event = WebSocketChatClientEvent;
+    public readonly state?: ChatStateTracker;
 
     protected ws: WebSocket|null = null;
     protected sendQueue: [commandType: keyof CommandsMap, commandData: any][] = [];
@@ -35,7 +35,7 @@ export class WebSocketClient extends AbstractClient implements ObservableInterfa
             throw new Error('Token or temporary nick is required');
         }
         if (this.options.stateTracking ?? true) {
-            this.state = new WebSocketStateTracker(this);
+            this.state = new ChatStateTracker(this);
         }
     }
 
@@ -80,6 +80,10 @@ export class WebSocketClient extends AbstractClient implements ObservableInterfa
 
     private onMessage(event: MessageEvent): void {
         const envelope: Envelope = JSON.parse(event.data);
+        this.handleIncomingEnvelope(envelope);
+        this.emit(envelope.type, envelope.data);
+        this.emit(this.Event.message, envelope);
+
         // Login successfully
         if (!this.authenticated) {
             const isAuthenticated = envelope.type !== 'Error';
@@ -92,9 +96,6 @@ export class WebSocketClient extends AbstractClient implements ObservableInterfa
                 this.authenticatedResolvers[1](envelope.data);
             }
         }
-        this.handleIncomingEnvelope(envelope);
-        this.emit(envelope.type, envelope);
-        this.emit(this.Event.message, envelope);
     }
 
     private onClose(event: CloseEvent): void {

package/src/index.ts

@@ -1,14 +1,16 @@
-import {WebSocketClient} from "./WebSocketClient";
-import {WebApiClient} from "./WebApiClient";
+import {WebSocketChatClient} from "./WebSocketChatClient";
+import {WebApiChatClient} from "./WebApiChatClient";
 import {
     IndexedCollection,
     IndexedObjectCollection,
     ObservableIndexedCollection,
     ObservableIndexedObjectCollection
 } from "./IndexedObjectCollection";
+import { AuthClient } from "./AuthClient";
 
 export {
     IndexedCollection, ObservableIndexedCollection,
     IndexedObjectCollection, ObservableIndexedObjectCollection,
-    WebSocketClient, WebApiClient,
+    WebSocketChatClient, WebApiChatClient,
+    AuthClient
 };

package/webpack.config.js

@@ -33,7 +33,7 @@ module.exports = {
     clean: true
   },
   optimization: {
-    minimize: true,
+    minimize: false,
     minimizer: [
       new TerserPlugin({ extractComments: false }),
       //new CssMinimizerPlugin()