@push.rocks/smartsocket 2.0.27 → 3.0.0

package/ts/smartsocket.classes.socketrequest.ts

@@ -1,4 +1,5 @@
 import * as plugins from './smartsocket.plugins.js';
+import * as interfaces from './interfaces/index.js';
 
 // import interfaces
 import {
@@ -78,11 +79,15 @@ export class SocketRequest<T extends plugins.typedrequestInterfaces.ITypedReques
    * dispatches a socketrequest from the requesting to the receiving side
    */
   public dispatch(): Promise<ISocketFunctionCallDataResponse<T>> {
-    const requestData: ISocketRequestDataObject<T> = {
-      funcCallData: this.funcCallData,
-      shortId: this.shortid,
+    const message: interfaces.ISocketMessage<interfaces.IFunctionCallPayload> = {
+      type: 'function',
+      id: this.shortid,
+      payload: {
+        funcName: this.funcCallData.funcName,
+        funcData: this.funcCallData.funcDataArg,
+      },
     };
-    this.originSocketConnection.socket.emit('function', requestData);
+    this.originSocketConnection.sendMessage(message);
     return this.done.promise;
   }
 
@@ -90,7 +95,6 @@ export class SocketRequest<T extends plugins.typedrequestInterfaces.ITypedReques
    * handles the response that is received by the requesting side
    */
   public async handleResponse(responseDataArg: ISocketRequestDataObject<T>) {
-    // logger.log('info', 'handling response!');
     this.done.resolve(responseDataArg.funcCallData);
     this.smartsocketRef.socketRequests.remove(this);
   }
@@ -110,16 +114,19 @@ export class SocketRequest<T extends plugins.typedrequestInterfaces.ITypedReques
       logger.log('error', `There is no SocketFunction defined for ${this.funcCallData.funcName}`);
       return;
     }
-    // logger.log('info', `invoking ${targetSocketFunction.name}`);
+
     targetSocketFunction
       .invoke(this.funcCallData, this.originSocketConnection)
       .then((resultData) => {
-        // logger.log('info', 'got resultData. Sending it to requesting party.');
-        const responseData: ISocketRequestDataObject<T> = {
-          funcCallData: resultData,
-          shortId: this.shortid,
+        const message: interfaces.ISocketMessage<interfaces.IFunctionCallPayload> = {
+          type: 'functionResponse',
+          id: this.shortid,
+          payload: {
+            funcName: resultData.funcName,
+            funcData: resultData.funcDataArg,
+          },
         };
-        this.originSocketConnection.socket.emit('functionResponse', responseData);
+        this.originSocketConnection.sendMessage(message);
         this.smartsocketRef.socketRequests.remove(this);
       });
   }

package/ts/smartsocket.classes.socketserver.ts

@@ -6,16 +6,16 @@ import { Smartsocket } from './smartsocket.classes.smartsocket.js';
 import { logger } from './smartsocket.logging.js';
 
 /**
- * class socketServer
- * handles the attachment of socketIo to whatever server is in play
+ * class SocketServer
+ * handles the WebSocket server in standalone mode, or provides hooks for smartserve integration
  */
 export class SocketServer {
   private smartsocket: Smartsocket;
-  private httpServerDeferred: plugins.smartpromise.Deferred<any>;
   private httpServer: pluginsTyped.http.Server | pluginsTyped.https.Server;
+  private wsServer: pluginsTyped.ws.WebSocketServer;
 
   /**
-   * wether httpServer is standalone
+   * whether httpServer is standalone (created by us)
    */
   private standaloneServer = false;
 
@@ -24,71 +24,180 @@ export class SocketServer {
   }
 
   /**
-   * starts the server with another server
-   * also works with an express style server
+   * Starts listening to incoming websocket connections (standalone mode).
+   * If no port is specified, this is a no-op (hooks mode via smartserve).
    */
-  public async setExternalServer(
-    serverType: 'smartexpress',
-    serverArg: pluginsTyped.typedserver.servertools.Server
-  ) {
-    this.httpServerDeferred = plugins.smartpromise.defer();
-    await serverArg.startedPromise;
-    this.httpServer = serverArg.httpServer;
-    this.httpServerDeferred.resolve();
-  }
-
-  /**
-   * gets the server for socket.io
-   */
-  public async getServerForSocketIo() {
-    if (this.httpServerDeferred) {
-      await this.httpServerDeferred.promise;
-    }
-    if (this.httpServer) {
-      return this.httpServer;
-    } else {
-      const httpModule = await this.smartsocket.smartenv.getSafeNodeModule('http');
-      this.httpServer = new httpModule.Server();
-      this.standaloneServer = true;
-      return this.httpServer;
+  public async start() {
+    // If no port specified, we're in hooks mode - nothing to start
+    if (!this.smartsocket.options.port) {
+      return;
     }
+
+    // Standalone mode - create our own HTTP server and WebSocket server
+    const done = plugins.smartpromise.defer();
+    const httpModule = await this.smartsocket.smartenv.getSafeNodeModule('http');
+    const wsModule = await this.smartsocket.smartenv.getSafeNodeModule('ws');
+
+    this.httpServer = httpModule.createServer();
+    this.standaloneServer = true;
+
+    // Create WebSocket server attached to HTTP server
+    this.wsServer = new wsModule.WebSocketServer({ server: this.httpServer });
+
+    this.wsServer.on('connection', (ws: pluginsTyped.ws.WebSocket) => {
+      this.smartsocket.handleNewConnection(ws);
+    });
+
+    this.httpServer.listen(this.smartsocket.options.port, () => {
+      logger.log(
+        'success',
+        `Server started in standalone mode on port ${this.smartsocket.options.port}`
+      );
+      done.resolve();
+    });
+
+    await done.promise;
   }
 
   /**
-   * starts listening to incoming sockets:
+   * closes the server
    */
-  public async start() {
-    const done = plugins.smartpromise.defer();
+  public async stop() {
+    const done = plugins.smartpromise.defer<void>();
+    let resolved = false;
+
+    if (this.wsServer) {
+      // Close all WebSocket connections
+      this.wsServer.clients.forEach((client) => {
+        client.terminate();
+      });
+      this.wsServer.close();
+      this.wsServer = null;
+    }
 
-    // handle http servers
-    // in case an external server has been set "this.standaloneServer" should be false
     if (this.httpServer && this.standaloneServer) {
-      if (!this.smartsocket.options.port) {
-        logger.log('error', 'there should be a port specifed for smartsocket!');
-        throw new Error('there should be a port specified for smartsocket');
-      }
-      this.httpServer.listen(this.smartsocket.options.port, () => {
-        logger.log(
-          'success',
-          `Server started in standalone mode on ${this.smartsocket.options.port}`
-        );
-        done.resolve();
+      const resolveOnce = () => {
+        if (!resolved) {
+          resolved = true;
+          this.httpServer = null;
+          this.standaloneServer = false;
+          done.resolve();
+        }
+      };
+
+      this.httpServer.close(() => {
+        resolveOnce();
       });
+
+      // Add a timeout in case close callback doesn't fire
+      const timeoutId = setTimeout(() => {
+        resolveOnce();
+      }, 2000);
+
+      // Ensure timeout doesn't keep process alive
+      if (timeoutId.unref) {
+        timeoutId.unref();
+      }
     } else {
       done.resolve();
     }
 
-    // nothing else to do if express server is set
     await done.promise;
-    return;
   }
 
   /**
-   * closes the server
+   * Returns WebSocket hooks for integration with smartserve.
+   * Pass these hooks to SmartServe's websocket config.
    */
-  public async stop() {
-    if (this.httpServer) {
-      this.httpServer.close();
-    }
+  public getSmartserveWebSocketHooks(): pluginsTyped.ISmartserveWebSocketHooks {
+    return {
+      onOpen: async (peer: pluginsTyped.ISmartserveWebSocketPeer) => {
+        // Create a wrapper that adapts ISmartserveWebSocketPeer to WebSocket-like interface
+        const wsLikeSocket = this.createWsLikeFromPeer(peer);
+        await this.smartsocket.handleNewConnection(wsLikeSocket as any);
+      },
+      onMessage: async (peer: pluginsTyped.ISmartserveWebSocketPeer, message: pluginsTyped.ISmartserveWebSocketMessage) => {
+        // Dispatch message to the SocketConnection via the adapter
+        const adapter = peer.data.get('smartsocket_adapter') as any;
+        if (adapter) {
+          let textData: string | undefined;
+          if (message.type === 'text' && message.text) {
+            textData = message.text;
+          } else if (message.type === 'binary' && message.data) {
+            // Convert binary to text (Buffer/Uint8Array to string)
+            textData = new TextDecoder().decode(message.data);
+          }
+          if (textData) {
+            adapter.dispatchMessage(textData);
+          }
+        }
+      },
+      onClose: async (peer: pluginsTyped.ISmartserveWebSocketPeer, code: number, reason: string) => {
+        // Dispatch close to the SocketConnection via the adapter
+        const adapter = peer.data.get('smartsocket_adapter') as any;
+        if (adapter) {
+          adapter.dispatchClose();
+        }
+      },
+      onError: async (peer: pluginsTyped.ISmartserveWebSocketPeer, error: Error) => {
+        // Dispatch error to the SocketConnection via the adapter
+        const adapter = peer.data.get('smartsocket_adapter') as any;
+        if (adapter) {
+          adapter.dispatchError();
+        }
+      },
+    };
+  }
+
+  /**
+   * Creates a WebSocket-like object from a smartserve peer
+   * This allows our SocketConnection to work with both native WebSocket and smartserve peers
+   */
+  private createWsLikeFromPeer(peer: pluginsTyped.ISmartserveWebSocketPeer): any {
+    const messageListeners: Array<(event: any) => void> = [];
+    const closeListeners: Array<() => void> = [];
+    const errorListeners: Array<() => void> = [];
+
+    // Store the adapter on the peer for message routing
+    peer.data.set('smartsocket_adapter', {
+      dispatchMessage: (data: string) => {
+        messageListeners.forEach((listener) => {
+          listener({ data });
+        });
+      },
+      dispatchClose: () => {
+        closeListeners.forEach((listener) => listener());
+      },
+      dispatchError: () => {
+        errorListeners.forEach((listener) => listener());
+      },
+    });
+
+    return {
+      readyState: peer.readyState,
+      send: (data: string) => peer.send(data),
+      close: (code?: number, reason?: string) => peer.close(code, reason),
+      addEventListener: (event: string, listener: any) => {
+        if (event === 'message') {
+          messageListeners.push(listener);
+        } else if (event === 'close') {
+          closeListeners.push(listener);
+        } else if (event === 'error') {
+          errorListeners.push(listener);
+        }
+      },
+      removeEventListener: (event: string, listener: any) => {
+        if (event === 'message') {
+          const idx = messageListeners.indexOf(listener);
+          if (idx >= 0) messageListeners.splice(idx, 1);
+        } else if (event === 'close') {
+          const idx = closeListeners.indexOf(listener);
+          if (idx >= 0) closeListeners.splice(idx, 1);
+        } else if (event === 'error') {
+          const idx = errorListeners.indexOf(listener);
+          if (idx >= 0) errorListeners.splice(idx, 1);
+        }
+      },
+    };
   }
 }

package/ts/smartsocket.pluginstyped.ts

@@ -4,20 +4,43 @@ import type * as https from 'https';
 
 export type { http, https };
 
-// pushrocks scope
-import type * as typedserver from '@api.global/typedserver';
+// third party scope - ws types
+import type * as wsTypes from 'ws';
 
-export type { typedserver };
+export namespace ws {
+  export type WebSocket = wsTypes.WebSocket;
+  export type WebSocketServer = wsTypes.WebSocketServer;
+  export type RawData = wsTypes.RawData;
+}
 
-// third party scope
-import type { Socket as ServerSocket, Server as ServerServer } from 'socket.io';
-import type { Socket as ClientSocket, connect as ClientIo } from 'socket.io-client';
+// smartserve compatibility interface (for setExternalServer)
+// This mirrors the IWebSocketPeer interface from smartserve
+export interface ISmartserveWebSocketPeer {
+  id: string;
+  url: string;
+  readyState: 0 | 1 | 2 | 3;
+  protocol: string;
+  extensions: string;
+  send(data: string): void;
+  sendBinary(data: Uint8Array | ArrayBuffer): void;
+  close(code?: number, reason?: string): void;
+  ping(data?: Uint8Array): void;
+  terminate(): void;
+  context: any;
+  data: Map<string, unknown>;
+  tags: Set<string>;
+}
 
-export namespace socketIo {
-  export type Socket = ServerSocket;
-  export type Server = ServerServer;
+export interface ISmartserveWebSocketMessage {
+  type: 'text' | 'binary';
+  text?: string;
+  data?: Uint8Array;
+  size: number;
 }
-export namespace socketIoClient {
-  export type Socket = ClientSocket;
-  export type connect = typeof ClientIo;
+
+export interface ISmartserveWebSocketHooks {
+  onOpen?: (peer: ISmartserveWebSocketPeer) => void | Promise<void>;
+  onMessage?: (peer: ISmartserveWebSocketPeer, message: ISmartserveWebSocketMessage) => void | Promise<void>;
+  onClose?: (peer: ISmartserveWebSocketPeer, code: number, reason: string) => void | Promise<void>;
+  onError?: (peer: ISmartserveWebSocketPeer, error: Error) => void | Promise<void>;
 }