@push.rocks/smartsocket 2.1.0 → 4.0.0

package/ts/smartsocket.classes.smartsocketclient.ts

@@ -16,7 +16,7 @@ import { logger } from './smartsocket.logging.js';
 export interface ISmartsocketClientOptions {
   port: number;
   url: string;
-  alias: string; // an alias makes it easier to identify this client in a multo client environment
+  alias: string; // an alias makes it easier to identify this client in a multi client environment
   autoReconnect?: boolean;
   maxRetries?: number; // maximum number of reconnection attempts
   initialBackoffDelay?: number; // initial backoff delay in ms
@@ -97,115 +97,170 @@ export class SmartsocketClient {
     this.socketFunctions.add(socketFunction);
   }
 
+  private isReconnecting = false;
+  private isConnecting = false;
+
   /**
    * connect the client to the server
    */
   public async connect() {
-    // Reset retry counters on new connection attempt
-    this.currentRetryCount = 0;
-    this.currentBackoffDelay = this.initialBackoffDelay;
-    
+    // Prevent duplicate connection attempts
+    if (this.isConnecting) {
+      return;
+    }
+    this.isConnecting = true;
+
+    // Only reset retry counters on fresh connection (not during auto-reconnect)
+    if (!this.isReconnecting) {
+      this.currentRetryCount = 0;
+      this.currentBackoffDelay = this.initialBackoffDelay;
+    }
+    this.isReconnecting = false;
+
     const done = plugins.smartpromise.defer();
     const smartenvInstance = new plugins.smartenv.Smartenv();
-    const socketIoClient: any = await smartenvInstance.getEnvAwareModule({
-      nodeModuleName: 'socket.io-client',
-      webUrlArg: 'https://cdn.jsdelivr.net/npm/socket.io-client@4/dist/socket.io.js',
-      getFunction: () => {
-        const socketIoBrowserModule = (globalThis as any).io;
-        // console.log('loaded socket.io for browser');
-        return socketIoBrowserModule;
-      },
-    });
-    // console.log(socketIoClient);
+
     logger.log('info', 'trying to connect...');
-    const socketUrl = `${this.serverUrl}:${this.serverPort}`;
+
+    // Construct WebSocket URL
+    const protocol = this.serverUrl.startsWith('https') ? 'wss' : 'ws';
+    const host = this.serverUrl.replace(/^https?:\/\//, '');
+    const socketUrl = `${protocol}://${host}:${this.serverPort}`;
+
+    // Get WebSocket implementation (native in browser, ws in Node)
+    let WebSocketClass: typeof WebSocket;
+    if (typeof WebSocket !== 'undefined') {
+      // Browser environment
+      WebSocketClass = WebSocket;
+    } else {
+      // Node.js environment
+      const wsModule = await smartenvInstance.getSafeNodeModule('ws');
+      WebSocketClass = wsModule.default || wsModule;
+    }
+
+    const socket = new WebSocketClass(socketUrl);
+    this.currentSocket = socket;
+
     this.socketConnection = new SocketConnection({
       alias: this.alias,
       authenticated: false,
       side: 'client',
       smartsocketHost: this,
-      socket: await socketIoClient
-        .connect(socketUrl, {
-          multiplex: true,
-          rememberUpgrade: true,
-          autoConnect: false,
-          reconnectionAttempts: 0,
-          rejectUnauthorized: socketUrl.startsWith('https://localhost') ? false : true,
-        })
-        .open(),
+      socket: socket as any,
     });
 
+    // Increment attempt ID to invalidate any pending timers from previous attempts
+    this.connectionAttemptId++;
+    const currentAttemptId = this.connectionAttemptId;
+
     const timer = new plugins.smarttime.Timer(5000);
     timer.start();
     timer.completed.then(() => {
-      this.updateStatus('timedOut');
-      logger.log('warn', 'connection to server timed out.');
-      this.disconnect(true);
+      // Only fire timeout if this is still the current connection attempt
+      if (currentAttemptId === this.connectionAttemptId && this.eventStatus !== 'connected') {
+        this.updateStatus('timedOut');
+        logger.log('warn', 'connection to server timed out.');
+        this.disconnect(true);
+      }
     });
 
-    // authentication flow
-    this.socketConnection.socket.on('requestAuth', (dataArg: interfaces.IRequestAuthPayload) => {
+    // Handle connection open
+    socket.addEventListener('open', () => {
       timer.reset();
-      logger.log('info', `server ${dataArg.serverAlias} requested authentication`);
-
-      // lets register the authenticated event
-      this.socketConnection.socket.on('authenticated', async () => {
-        this.remoteShortId = dataArg.serverAlias;
-        logger.log('info', 'client is authenticated');
-        this.socketConnection.authenticated = true;
-        await this.socketConnection.listenToFunctionRequests();
-      });
-
-      this.socketConnection.socket.on('serverFullyReactive', async () => {
-        // lets take care of retagging
-        const oldTagStore = this.tagStore;
-        this.tagStoreSubscription?.unsubscribe();
-        for (const keyArg of Object.keys(this.tagStore)) {
-          this.socketConnection.addTag(this.tagStore[keyArg]);
-        }
-        this.tagStoreSubscription = this.socketConnection.tagStoreObservable.subscribe(
-          (tagStoreArg) => {
-            this.tagStore = tagStoreArg;
-          }
-        );
+    });
+
+    // Handle messages
+    socket.addEventListener('message', async (event: MessageEvent | { data: string }) => {
+      try {
+        const data = typeof event.data === 'string' ? event.data : event.data.toString();
+        const message: interfaces.ISocketMessage = JSON.parse(data);
+
+        switch (message.type) {
+          case 'authRequest':
+            timer.reset();
+            const authRequestPayload = message.payload as interfaces.IAuthRequestPayload;
+            logger.log('info', `server ${authRequestPayload.serverAlias} requested authentication`);
+            this.remoteShortId = authRequestPayload.serverAlias;
 
-        for (const tag of Object.keys(oldTagStore)) {
-          await this.addTag(oldTagStore[tag]);
+            // Send authentication data
+            this.socketConnection.sendMessage({
+              type: 'auth',
+              payload: { alias: this.alias },
+            });
+            break;
+
+          case 'authResponse':
+            const authResponse = message.payload as interfaces.IAuthResponsePayload;
+            if (authResponse.success) {
+              logger.log('info', 'client is authenticated');
+              this.socketConnection.authenticated = true;
+            } else {
+              logger.log('warn', `authentication failed: ${authResponse.error}`);
+              await this.disconnect();
+            }
+            break;
+
+          case 'serverReady':
+            // Set up function request listening
+            await this.socketConnection.listenToFunctionRequests();
+
+            // Handle retagging
+            const oldTagStore = this.tagStore;
+            this.tagStoreSubscription?.unsubscribe();
+            for (const keyArg of Object.keys(this.tagStore)) {
+              this.socketConnection.addTag(this.tagStore[keyArg]);
+            }
+            this.tagStoreSubscription = this.socketConnection.tagStoreObservable.subscribe(
+              (tagStoreArg) => {
+                this.tagStore = tagStoreArg;
+              }
+            );
+
+            for (const tag of Object.keys(oldTagStore)) {
+              await this.addTag(oldTagStore[tag]);
+            }
+            this.updateStatus('connected');
+            this.isConnecting = false;
+            done.resolve();
+            break;
+
+          default:
+            // Other messages are handled by SocketConnection
+            this.socketConnection.handleMessage(message);
+            break;
         }
-        this.updateStatus('connected');
-        done.resolve();
-      });
-
-      // lets register the forbidden event
-      this.socketConnection.socket.on('forbidden', async () => {
-        logger.log('warn', `disconnecting due to being forbidden to use the ressource`);
-        await this.disconnect();
-      });
-
-      // lets provide the actual auth data
-      this.socketConnection.socket.emit('dataAuth', {
-        alias: this.alias,
-      });
+      } catch (err) {
+        // Not a valid JSON message, ignore
+      }
     });
 
-    // handle connection
-    this.socketConnection.socket.on('connect', async () => {});
+    // Handle disconnection and errors
+    const closeHandler = async () => {
+      // Only handle close if this is still the current socket and we're not already disconnecting
+      if (this.currentSocket === socket && !this.disconnectRunning) {
+        logger.log(
+          'info',
+          `SocketConnection with >alias ${this.alias} on >side client disconnected`
+        );
+        await this.disconnect(true);
+      }
+    };
 
-    // handle disconnection and errors
-    this.socketConnection.socket.on('disconnect', async () => {
-      await this.disconnect(true);
-    });
+    const errorHandler = async () => {
+      if (this.currentSocket === socket && !this.disconnectRunning) {
+        await this.disconnect(true);
+      }
+    };
+
+    socket.addEventListener('close', closeHandler);
+    socket.addEventListener('error', errorHandler);
 
-    this.socketConnection.socket.on('reconnect_failed', async () => {
-      await this.disconnect(true);
-    });
-    this.socketConnection.socket.on('connect_error', async () => {
-      await this.disconnect(true);
-    });
     return done.promise;
   }
 
   private disconnectRunning = false;
+  private currentSocket: WebSocket | null = null;
+  private connectionAttemptId = 0; // Increment on each connect attempt to invalidate old timers
 
   /**
    * disconnect from the server
@@ -215,13 +270,19 @@ export class SmartsocketClient {
       return;
     }
     this.disconnectRunning = true;
+    this.isConnecting = false;
     this.updateStatus('disconnecting');
     this.tagStoreSubscription?.unsubscribe();
+
+    // Store reference to current socket before cleanup
+    const socketToClose = this.currentSocket;
+    this.currentSocket = null;
+
     if (this.socketConnection) {
       await this.socketConnection.disconnect();
       this.socketConnection = undefined;
       logger.log('ok', 'disconnected socket!');
-    } else {
+    } else if (!socketToClose) {
       this.disconnectRunning = false;
       logger.log('warn', 'tried to disconnect, without a SocketConnection');
       return;
@@ -232,28 +293,29 @@ export class SmartsocketClient {
 
     if (this.autoReconnect && useAutoReconnectSetting && this.eventStatus !== 'connecting') {
       this.updateStatus('connecting');
-      
+
       // Check if we've exceeded the maximum number of retries
       if (this.currentRetryCount >= this.maxRetries) {
         logger.log('warn', `Maximum reconnection attempts (${this.maxRetries}) reached. Giving up.`);
         this.disconnectRunning = false;
         return;
       }
-      
+
       // Increment retry counter
       this.currentRetryCount++;
-      
+
       // Calculate backoff with jitter (±20% randomness)
       const jitter = this.currentBackoffDelay * 0.2 * (Math.random() * 2 - 1);
       const delay = Math.min(this.currentBackoffDelay + jitter, this.maxBackoffDelay);
-      
+
       logger.log('info', `Reconnect attempt ${this.currentRetryCount}/${this.maxRetries} in ${Math.round(delay)}ms`);
-      
+
       // Apply exponential backoff for next time (doubling with each attempt)
       this.currentBackoffDelay = Math.min(this.currentBackoffDelay * 2, this.maxBackoffDelay);
-      
+
       await plugins.smartdelay.delayFor(delay);
       this.disconnectRunning = false;
+      this.isReconnecting = true;
       await this.connect();
     } else {
       this.disconnectRunning = false;
@@ -279,7 +341,6 @@ export class SmartsocketClient {
     functionNameArg: T['method'],
     dataArg: T['request']
   ): Promise<T['response']> {
-    const done = plugins.smartpromise.defer();
     const socketRequest = new SocketRequest<T>(this, {
       side: 'requesting',
       originSocketConnection: this.socketConnection,
@@ -299,14 +360,14 @@ export class SmartsocketClient {
       this.eventSubject.next(statusArg);
     }
     this.eventStatus = statusArg;
-    
+
     // Reset reconnection state when connection is successful
     if (statusArg === 'connected') {
       this.currentRetryCount = 0;
       this.currentBackoffDelay = this.initialBackoffDelay;
     }
   }
-  
+
   /**
    * Resets the reconnection state
    */

package/ts/smartsocket.classes.socketconnection.ts

@@ -26,7 +26,7 @@ export interface ISocketConnectionConstructorOptions {
   authenticated: boolean;
   side: TSocketConnectionSide;
   smartsocketHost: Smartsocket | SmartsocketClient;
-  socket: pluginsTyped.socketIo.Socket | pluginsTyped.socketIoClient.Socket;
+  socket: pluginsTyped.TWebSocket | pluginsTyped.IWebSocketLike;
 }
 
 /**
@@ -47,7 +47,7 @@ export class SocketConnection {
   public side: TSocketConnectionSide;
   public authenticated: boolean = false;
   public smartsocketRef: Smartsocket | SmartsocketClient;
-  public socket: pluginsTyped.socketIo.Socket | pluginsTyped.socketIoClient.Socket;
+  public socket: pluginsTyped.TWebSocket | pluginsTyped.IWebSocketLike;
 
   public eventSubject = new plugins.smartrx.rxjs.Subject<interfaces.TConnectionStatus>();
   public eventStatus: interfaces.TConnectionStatus = 'new';
@@ -65,20 +65,94 @@ export class SocketConnection {
 
     // standard behaviour that is always true
     allSocketConnections.add(this);
+  }
 
-    // handle connection
-    this.socket.on('connect', async () => {
-      this.updateStatus('connected');
-    });
-    this.socket.on('disconnect', async () => {
-      logger.log(
-        'info',
-        `SocketConnection with >alias ${this.alias} on >side ${this.side} disconnected`
-      );
-      await this.disconnect();
-      allSocketConnections.remove(this);
-      this.eventSubject.next('disconnected');
-    });
+  /**
+   * Sends a message through the socket
+   */
+  public sendMessage(message: interfaces.ISocketMessage): void {
+    if (this.socket.readyState === 1) { // WebSocket.OPEN
+      this.socket.send(JSON.stringify(message));
+    }
+  }
+
+  /**
+   * Handles incoming messages
+   */
+  public handleMessage(messageData: interfaces.ISocketMessage): void {
+    switch (messageData.type) {
+      case 'function':
+        this.handleFunctionCall(messageData as interfaces.ISocketMessage<interfaces.IFunctionCallPayload>);
+        break;
+      case 'functionResponse':
+        this.handleFunctionResponse(messageData as interfaces.ISocketMessage<interfaces.IFunctionCallPayload>);
+        break;
+      case 'tagUpdate':
+        this.handleTagUpdate(messageData as interfaces.ISocketMessage<interfaces.ITagUpdatePayload>);
+        break;
+      default:
+        // Authentication messages are handled by the server/client classes
+        break;
+    }
+  }
+
+  private handleFunctionCall(messageData: interfaces.ISocketMessage<interfaces.IFunctionCallPayload>): void {
+    const requestData: ISocketRequestDataObject<any> = {
+      funcCallData: {
+        funcName: messageData.payload.funcName,
+        funcDataArg: messageData.payload.funcData,
+      },
+      shortId: messageData.id,
+    };
+
+    const referencedFunction: SocketFunction<any> =
+      this.smartsocketRef.socketFunctions.findSync((socketFunctionArg) => {
+        return socketFunctionArg.name === requestData.funcCallData.funcName;
+      });
+
+    if (referencedFunction) {
+      const localSocketRequest = new SocketRequest(this.smartsocketRef, {
+        side: 'responding',
+        originSocketConnection: this,
+        shortId: requestData.shortId,
+        funcCallData: requestData.funcCallData,
+      });
+      localSocketRequest.createResponse();
+    } else {
+      logger.log('warn', `function ${requestData.funcCallData.funcName} not found or out of scope`);
+    }
+  }
+
+  private handleFunctionResponse(messageData: interfaces.ISocketMessage<interfaces.IFunctionCallPayload>): void {
+    const responseData: ISocketRequestDataObject<any> = {
+      funcCallData: {
+        funcName: messageData.payload.funcName,
+        funcDataArg: messageData.payload.funcData,
+      },
+      shortId: messageData.id,
+    };
+
+    const targetSocketRequest = SocketRequest.getSocketRequestById(
+      this.smartsocketRef,
+      responseData.shortId
+    );
+    if (targetSocketRequest) {
+      targetSocketRequest.handleResponse(responseData);
+    }
+  }
+
+  private handleTagUpdate(messageData: interfaces.ISocketMessage<interfaces.ITagUpdatePayload>): void {
+    const tagStoreArg = messageData.payload.tags as interfaces.TTagStore;
+    if (!plugins.smartjson.deepEqualObjects(this.tagStore, tagStoreArg)) {
+      this.tagStore = tagStoreArg;
+      // Echo back to confirm
+      this.sendMessage({
+        type: 'tagUpdate',
+        payload: { tags: this.tagStore },
+      });
+      this.tagStoreObservable.next(this.tagStore);
+    }
+    this.remoteTagStoreObservable.next(tagStoreArg);
   }
 
   /**
@@ -99,54 +173,88 @@ export class SocketConnection {
         done.resolve();
       }
     });
-    this.socket.emit('updateTagStore', this.tagStore);
+    this.sendMessage({
+      type: 'tagUpdate',
+      payload: { tags: this.tagStore },
+    });
     await done.promise;
   }
 
   /**
-   * gets a tag by id
-   * @param tagIdArg
+   * Gets a tag by id
    */
-  public async getTagById(tagIdArg: interfaces.ITag['id']) {
+  public getTagById(tagIdArg: interfaces.ITag['id']): interfaces.ITag | undefined {
     return this.tagStore[tagIdArg];
   }
 
   /**
-   * removes a tag from a connection
+   * Removes a tag from a connection
    */
-  public async removeTagById(tagIdArg: interfaces.ITag['id']) {
+  public removeTagById(tagIdArg: interfaces.ITag['id']): void {
     delete this.tagStore[tagIdArg];
     this.tagStoreObservable.next(this.tagStore);
-    this.socket.emit('updateTagStore', this.tagStore);
+    this.sendMessage({
+      type: 'tagUpdate',
+      payload: { tags: this.tagStore },
+    });
   }
 
   // authenticating --------------------------
 
   /**
-   * authenticate the socket
+   * authenticate the socket (server side)
    */
-  public authenticate() {
-    const done = plugins.smartpromise.defer();
-    this.socket.on('dataAuth', async (dataArg: ISocketConnectionAuthenticationObject) => {
-      logger.log('info', 'received authentication data...');
-      this.socket.removeAllListeners('dataAuth');
-      if (dataArg.alias) {
-        // TODO: authenticate password
-        this.alias = dataArg.alias;
-        this.authenticated = true;
-        this.socket.emit('authenticated');
-        logger.log('ok', `socket with >>alias ${this.alias} is authenticated!`);
-        done.resolve(this);
-      } else {
-        this.authenticated = false;
-        await this.disconnect();
-        done.reject('a socket tried to connect, but could not authenticated.');
+  public authenticate(): Promise<SocketConnection> {
+    const done = plugins.smartpromise.defer<SocketConnection>();
+
+    // Set up message handler for authentication
+    const messageHandler = (event: pluginsTyped.TMessageEvent) => {
+      try {
+        const data = typeof event.data === 'string' ? event.data : event.data.toString();
+        const message: interfaces.ISocketMessage = JSON.parse(data);
+
+        if (message.type === 'auth') {
+          const authData = message.payload as interfaces.IAuthPayload;
+          logger.log('info', 'received authentication data...');
+
+          if (authData.alias) {
+            this.alias = authData.alias;
+            this.authenticated = true;
+
+            // Send authentication response
+            this.sendMessage({
+              type: 'authResponse',
+              payload: { success: true },
+            });
+
+            logger.log('ok', `socket with >>alias ${this.alias} is authenticated!`);
+            done.resolve(this);
+          } else {
+            this.authenticated = false;
+            this.sendMessage({
+              type: 'authResponse',
+              payload: { success: false, error: 'No alias provided' },
+            });
+            this.disconnect();
+            done.reject('a socket tried to connect, but could not authenticate.');
+          }
+        }
+      } catch (err) {
+        logger.log('warn', `Failed to parse auth message: ${err instanceof Error ? err.message : String(err)}`);
       }
-    });
-    const requestAuthPayload: interfaces.IRequestAuthPayload = {
-      serverAlias: this.smartsocketRef.alias,
     };
-    this.socket.emit('requestAuth', requestAuthPayload);
+
+    (this.socket as pluginsTyped.IWebSocketLike).addEventListener('message', messageHandler);
+
+    // Request authentication
+    const requestAuthPayload: interfaces.TAuthRequestMessage = {
+      type: 'authRequest',
+      payload: {
+        serverAlias: (this.smartsocketRef as Smartsocket).alias,
+      },
+    };
+    this.sendMessage(requestAuthPayload);
+
     return done.promise;
   }
 
@@ -158,43 +266,18 @@ export class SocketConnection {
   public listenToFunctionRequests() {
     const done = plugins.smartpromise.defer();
     if (this.authenticated) {
-      this.socket.on('function', (dataArg: ISocketRequestDataObject<any>) => {
-        // check if requested function is available to the socket's scope
-        // logger.log('info', 'function request received');
-        const referencedFunction: SocketFunction<any> =
-          this.smartsocketRef.socketFunctions.findSync((socketFunctionArg) => {
-            return socketFunctionArg.name === dataArg.funcCallData.funcName;
-          });
-        if (referencedFunction) {
-          // logger.log('ok', 'function in access scope');
-          const localSocketRequest = new SocketRequest(this.smartsocketRef, {
-            side: 'responding',
-            originSocketConnection: this,
-            shortId: dataArg.shortId,
-            funcCallData: dataArg.funcCallData,
-          });
-          localSocketRequest.createResponse(); // takes care of creating response and sending it back
-        } else {
-          logger.log('warn', 'function not existent or out of access scope');
+      // Set up message handler for all messages
+      const messageHandler = (event: pluginsTyped.TMessageEvent) => {
+        try {
+          const data = typeof event.data === 'string' ? event.data : event.data.toString();
+          const message: interfaces.ISocketMessage = JSON.parse(data);
+          this.handleMessage(message);
+        } catch (err) {
+          logger.log('warn', `Failed to parse socket message: ${err instanceof Error ? err.message : String(err)}`);
         }
-      });
-      this.socket.on('functionResponse', (dataArg: ISocketRequestDataObject<any>) => {
-        // logger.log('info', `received response for request with id ${dataArg.shortId}`);
-        const targetSocketRequest = SocketRequest.getSocketRequestById(
-          this.smartsocketRef,
-          dataArg.shortId
-        );
-        targetSocketRequest.handleResponse(dataArg);
-      });
+      };
 
-      this.socket.on('updateTagStore', async (tagStoreArg: interfaces.TTagStore) => {
-        if (!plugins.smartjson.deepEqualObjects(this.tagStore, tagStoreArg)) {
-          this.tagStore = tagStoreArg;
-          this.socket.emit('updateTagStore', this.tagStore);
-          this.tagStoreObservable.next(this.tagStore);
-        }
-        this.remoteTagStoreObservable.next(tagStoreArg);
-      });
+      (this.socket as pluginsTyped.IWebSocketLike).addEventListener('message', messageHandler);
 
       logger.log(
         'info',
@@ -211,7 +294,10 @@ export class SocketConnection {
 
   // disconnecting ----------------------
   public async disconnect() {
-    this.socket.disconnect(true);
+    if (this.socket.readyState === 1 || this.socket.readyState === 0) {
+      this.socket.close();
+    }
+    allSocketConnections.remove(this);
     this.updateStatus('disconnected');
   }