send and receive message

src/app/module/chat/infra/socket/signalR.ts

@@ -0,0 +1,140 @@
+import * as signalR from '@microsoft/signalr';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ok, Result, err } from 'neverthrow';
+import { SessionStore } from 'src/app/store/session.service';
+import { filter, first } from 'rxjs/operators';
+
+export class SignalRConnection {
+
+  private hubConnection: signalR.HubConnection;
+  private messageSubject: BehaviorSubject<string> = new BehaviorSubject<any>(null);
+  private connectionStateSubject: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);
+  private disconnectSubject: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);
+  private reconnectSubject: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);
+  private sendLaterSubject: BehaviorSubject<Object> = new BehaviorSubject<Object>(false);
+  private reconnect = true
+  url: string
+
+  constructor({url}) {
+    this.url = url
+  }
+
+  establishConnection(): Promise<Result<signalR.HubConnection, false>> {
+    return new Promise((resolve, reject) => {
+
+      const hubConnection = new signalR.HubConnectionBuilder()
+      .withUrl(this.url)
+      .build();
+
+      this.hubConnection = hubConnection
+      this.join()
+
+      hubConnection
+      .start()
+      .then(() => {
+        console.log('Connection started');
+        this.connectionStateSubject.next(true);
+        this.hubConnection = hubConnection
+        this.addMessageListener()
+        this.join()
+        resolve(ok(hubConnection))
+      })
+      .catch(error => {
+        console.log('Error while starting connection: ' + error);
+        this.connectionStateSubject.next(false);
+        reject(err(false))
+      });
+
+      hubConnection.onclose(() => {
+        console.log('Connection closed');
+        this.connectionStateSubject.next(false);
+        this.disconnectSubject.next(true)
+        if(this.reconnect) {
+          this.attempReconnect();
+        }
+
+      });
+    })
+  }
+
+
+  async attempReconnect() {
+    const attempConnection = await this.establishConnection()
+
+    if(attempConnection.isOk()) {
+      this.reconnectSubject.next(true)
+    }
+
+  }
+
+  public join() {
+    if(this.connectionStateSubject.value == true) {
+      console.log('join=============')
+      this.hubConnection.invoke("Join", 105, "UserFirefox");
+    } else {
+      this.sendLaterSubject.next({method: 'SendMessage', args:["Join", 312, "Daniel"]})
+    }
+
+  }
+
+  public async sendMessage(data: Object & { requestId}):Promise<Result<any, any>>  {
+    return new Promise((resolve, reject) => {
+
+      if(this.connectionStateSubject.value == true) {
+        console.log('sendMessage')
+        this.hubConnection.invoke("SendMessage", data)
+
+        this.messageSubject.pipe(
+          filter((message: any) => data.requestId == message?.requestId),
+          first()
+        ).subscribe(value => {
+          resolve(ok(value))
+          console.log('Received valid value:', value);
+        });
+
+      } else {
+        this.sendLaterSubject.next({method: 'SendMessage', args: data})
+        return reject(err(false))
+      }
+
+
+    })
+  }
+
+  private addMessageListener(): void {
+    this.hubConnection.on('ReceiveMessage', (message) => {
+      console.log('ReceiveMessage', message)
+      this.messageSubject.next(message);
+    });
+  }
+
+  public getMessages(): Observable<string> {
+    return this.messageSubject.asObservable()
+  }
+
+  public getConnectionState(): Observable<boolean> {
+    return this.connectionStateSubject.asObservable();
+  }
+
+  public getDisconnectTrigger(): Observable<boolean> {
+    return this.disconnectSubject.asObservable();
+  }
+
+  public getSendLater() {
+    return this.sendLaterSubject.asObservable();
+  }
+
+  public closeConnection(): void {
+    this.reconnect = false
+    if (this.hubConnection) {
+      this.hubConnection
+        .stop()
+        .then(() => {
+          console.log('Connection closed by user');
+          this.connectionStateSubject.next(false);
+        })
+        .catch(err => console.log('Error while closing connection: ' + err));
+    }
+  }
+
+}