@sogni-ai/sogni-client 4.0.0-alpha.12 → 4.0.0-alpha.14

package/src/ApiClient/WebSocketClient/BrowserWebSocketClient/types.ts

@@ -0,0 +1,107 @@
+import { SocketEventMap, SocketEventName } from '../events';
+import { MessageType, SocketMessageMap } from '../messages';
+
+/**
+ * Primary tab to broadcast socket events to secondary tabs.
+ * @param eventType - The event type.
+ * @param payload - The event payload. See {@link SocketEventMap} for the list of available events.
+ */
+export interface SocketEventReceived<T extends SocketEventName = SocketEventName> {
+  type: 'socket-event';
+  payload: { eventType: T; payload: SocketEventMap[T] };
+}
+
+/**
+ * Sent by secondary tabs to the primary tab to send a message to WebSocket.
+ * @param messageType - The message type.
+ * @param data - The message payload. See {@link SocketMessageMap} for the list of available messages.
+ */
+export interface SendSocketMessage<T extends MessageType = MessageType> {
+  type: 'socket-send';
+  payload: { messageType: T; data: SocketMessageMap[T] };
+}
+
+/**
+ * Sent by the primary tab to acknowledge that a message was sent to WebSocket.
+ */
+export interface SocketMessageAck {
+  type: 'socket-ack';
+  payload: { envelopeId: string };
+}
+
+/**
+ * Sent by the primary tab to notify the secondary tabs that the primary tab is still alive.
+ * @param connected - true if the primary tab is connected to the server, false otherwise.
+ */
+export interface Heartbeat {
+  type: 'primary-present';
+  payload: { connected: boolean };
+}
+
+/**
+ * Used to tell the primary tab to connect/disconnect socket.
+ * @param connected - true to connect, false to disconnect.
+ */
+export interface ConnectionToggle {
+  type: 'connection-toggle';
+  payload: { connected: boolean };
+}
+
+/**
+ * Sent by tab when it is opened to notify other tabs. If another tab is present,
+ * it will respond with {@link Heartbeat}.
+ */
+export interface ClientAnnounce {
+  type: 'announce';
+}
+
+/**
+ * Sent by the client to let other know that it is claiming the primary role.
+ */
+export interface PrimaryClaim {
+  type: 'primary-claim';
+}
+
+/**
+ * Sent by the client to let other know that it is releasing the primary role.
+ * This usually happens when the tab is closed.
+ */
+export interface PrimaryRelease {
+  type: 'primary-release';
+}
+
+/**
+ * Sent by the tab where user has auth state changed.
+ * @param authenticated - true if the user is authenticated, false otherwise.
+ */
+export interface AuthenticationChange {
+  type: 'authentication';
+  payload: { authenticated: boolean };
+}
+
+export type ChannelMessage =
+  | AuthenticationChange
+  | SocketEventReceived
+  | SendSocketMessage
+  | SocketMessageAck
+  | ConnectionToggle
+  | Heartbeat
+  | ClientAnnounce
+  | PrimaryClaim
+  | PrimaryRelease;
+
+/**
+ * Envelope for messages sent between tabs.
+ * @param id - Unique message ID.
+ * @param senderId - ID of the tab that sent the message.
+ * @param recipientId - ID of the tab that should receive the message. If not specified, the message will be broadcasted to all tabs.
+ * @param timestamp - Timestamp of the message.
+ * @param payload - Message payload.
+ */
+export interface MessageEnvelope {
+  id: string;
+  senderId: string;
+  recipientId?: string;
+  timestamp: number;
+  payload: ChannelMessage;
+}

package/src/ApiClient/WebSocketClient/events.ts

@@ -148,3 +148,5 @@ export type SocketEventMap = {
 
   artistCancelConfirmation: ArtistCancelConfirmation;
 };
+
+export type SocketEventName = keyof SocketEventMap;

package/src/ApiClient/WebSocketClient/index.ts

@@ -1,7 +1,7 @@
 import { MessageType, SocketMessageMap } from './messages';
 import { SocketEventMap } from './events';
 import RestClient from '../../lib/RestClient';
-import { SupernetType } from './types';
+import { IWebSocketClient, SupernetType } from './types';
 import WebSocket, { CloseEvent, ErrorEvent, MessageEvent } from 'isomorphic-ws';
 import { base64Decode, base64Encode } from '../../lib/base64';
 import isNodejs from '../../lib/isNodejs';
@@ -13,7 +13,7 @@ const PROTOCOL_VERSION = '3.0.0';
 
 const PING_INTERVAL = 15000;
 
-class WebSocketClient extends RestClient<SocketEventMap> {
+class WebSocketClient extends RestClient<SocketEventMap> implements IWebSocketClient {
   appId: string;
   baseUrl: string;
   private socket: WebSocket | null = null;

package/src/ApiClient/WebSocketClient/types.ts

@@ -1 +1,17 @@
+import { MessageType, SocketMessageMap } from './messages';
+import RestClient from '../../lib/RestClient';
+import { SocketEventMap } from './events';
+
 export type SupernetType = 'relaxed' | 'fast';
+
+export interface IWebSocketClient extends RestClient<SocketEventMap> {
+  appId: string;
+  baseUrl: string;
+  isConnected: boolean;
+  supernetType: SupernetType;
+
+  connect(): Promise<void>;
+  disconnect(): void;
+  send<T extends MessageType>(messageType: T, data: SocketMessageMap[T]): Promise<void>;
+  switchNetwork(supernetType: SupernetType): Promise<SupernetType>;
+}

package/src/ApiClient/index.ts

@@ -3,12 +3,14 @@ import WebSocketClient from './WebSocketClient';
 import TypedEventEmitter from '../lib/TypedEventEmitter';
 import { ApiClientEvents } from './events';
 import { ServerConnectData, ServerDisconnectData } from './WebSocketClient/events';
-import { isNotRecoverable } from './WebSocketClient/ErrorCode';
+import { ErrorCode, isNotRecoverable } from './WebSocketClient/ErrorCode';
 import { JSONValue } from '../types/json';
-import { SupernetType } from './WebSocketClient/types';
+import { IWebSocketClient, SupernetType } from './WebSocketClient/types';
 import { Logger } from '../lib/DefaultLogger';
 import CookieAuthManager from '../lib/AuthManager/CookieAuthManager';
 import { AuthManager, TokenAuthManager } from '../lib/AuthManager';
+import isNodejs from '../lib/isNodejs';
+import BrowserWebSocketClient from './WebSocketClient/BrowserWebSocketClient';
 
 const WS_RECONNECT_ATTEMPTS = 5;
 
@@ -48,7 +50,7 @@ class ApiClient extends TypedEventEmitter<ApiClientEvents> {
   readonly appId: string;
   readonly logger: Logger;
   private _rest: RestClient;
-  private _socket: WebSocketClient;
+  private _socket: IWebSocketClient;
   private _auth: AuthManager;
   private _reconnectAttempts = WS_RECONNECT_ATTEMPTS;
   private _disableSocket: boolean = false;
@@ -68,7 +70,12 @@ class ApiClient extends TypedEventEmitter<ApiClientEvents> {
     this._auth =
       authType === 'token' ? new TokenAuthManager(baseUrl, logger) : new CookieAuthManager(logger);
     this._rest = new RestClient(baseUrl, this._auth, logger);
-    this._socket = new WebSocketClient(socketUrl, this._auth, appId, networkType, logger);
+    // Use coordinated WebSocket client in browser, regular in Node.js
+    if (this._auth instanceof TokenAuthManager || isNodejs) {
+      this._socket = new WebSocketClient(socketUrl, this._auth, appId, networkType, logger);
+    } else {
+      this._socket = new BrowserWebSocketClient(socketUrl, this._auth, appId, networkType, logger);
+    }
     this._disableSocket = disableSocket;
     this._auth.on('updated', this.handleAuthUpdated.bind(this));
     this._socket.on('connected', this.handleSocketConnect.bind(this));
@@ -83,7 +90,7 @@ class ApiClient extends TypedEventEmitter<ApiClientEvents> {
     return this._auth;
   }
 
-  get socket(): WebSocketClient {
+  get socket(): IWebSocketClient {
     return this._socket;
   }
 
@@ -101,14 +108,26 @@ class ApiClient extends TypedEventEmitter<ApiClientEvents> {
   }
 
   handleSocketDisconnect(data: ServerDisconnectData) {
+    // If user is not authenticated, we don't need to reconnect
+    if (!this.auth.isAuthenticated) {
+      this.emit('disconnected', data);
+      return;
+    }
     if (!data.code || isNotRecoverable(data.code)) {
+      // If this is browser, another tab is probably claiming the connection, so we don't need to reconnect
+      if (
+        this._socket instanceof BrowserWebSocketClient &&
+        data.code === ErrorCode.SWITCH_CONNECTION
+      ) {
+        this.logger.debug('Switching network connection, not reconnecting');
+        return;
+      }
       this.auth.clear();
       this.emit('disconnected', data);
       this.logger.error('Not recoverable socket error', data);
       return;
     }
     if (this._reconnectAttempts <= 0) {
-      this.auth.clear();
       this.emit('disconnected', data);
       this._reconnectAttempts = WS_RECONNECT_ATTEMPTS;
       return;

package/src/index.ts

@@ -63,7 +63,7 @@ export interface SogniClientConfig {
   socketEndpoint?: string;
   /**
    * Disable WebSocket connection. Useful for testing or when WebSocket is not needed.
-   * Note that many may not work without WebSocket connection.
+   * Note that many APIs may not work without WebSocket connection.
    * @experimental
    * @internal
    */
@@ -141,9 +141,13 @@ export class SogniClient {
       throw Error('This method should only be called when using cookie auth');
     }
     try {
-      await this.apiClient.rest.get<ApiResponse<MeData>>('/v1/account/me');
+      const res = await this.apiClient.rest.get<ApiResponse<MeData>>('/v1/account/me');
       await auth.authenticate();
-      await this.account.me();
+      this.currentAccount._update({
+        username: res.data.username,
+        email: res.data.currentEmail,
+        walletAddress: res.data.walletAddress
+      });
       return true;
     } catch (e) {
       this.apiClient.logger.info('Client is not authenticated');

package/src/lib/DataEntity.ts

@@ -25,9 +25,11 @@ abstract class DataEntity<D, E extends EntityEvents = EntityEvents> extends Type
   _update(delta: Partial<D>) {
     //@ts-ignore
     const changedKeys = Object.keys(delta).filter((key) => this.data[key] !== delta[key]);
-    this.data = { ...this.data, ...delta };
     this.lastUpdated = new Date();
-    this.emit('updated', changedKeys);
+    if (changedKeys.length > 0) {
+      this.data = { ...this.data, ...delta };
+      this.emit('updated', changedKeys);
+    }
   }
 
   /**