@scpxl/nodejs-framework 1.0.13

package/dist/websocket/websocket-server.js

@@ -0,0 +1,686 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { WebSocketServer as WS, WebSocket } from "ws";
+import {
+  WebSocketRedisSubscriberEvent
+} from "./websocket.interface.js";
+import WebSocketClientManager from "./websocket-client-manager.js";
+import { generateClientId, log } from "./utils.js";
+import WebSocketBase from "./websocket-base.js";
+import { Logger } from "../logger/index.js";
+import path from "path";
+import { baseDir } from "../index.js";
+import WebSocketRoomManager from "./websocket-room-manager.js";
+import logger from "../logger/logger.js";
+import { URL } from "url";
+import Jwt from "../auth/jwt.js";
+class WebSocketServer extends WebSocketBase {
+  static {
+    __name(this, "WebSocketServer");
+  }
+  defaultRoutes = [
+    {
+      type: "system",
+      action: "joinRoom",
+      controllerName: "system"
+    },
+    {
+      type: "system",
+      action: "leaveRoom",
+      controllerName: "system"
+    }
+  ];
+  server;
+  checkConnectedClientsInterval;
+  workerId;
+  uniqueInstanceId;
+  applicationConfig;
+  options;
+  clientManager = new WebSocketClientManager();
+  roomManager = new WebSocketRoomManager({
+    clientManager: this.clientManager
+  });
+  get rooms() {
+    return this.roomManager.rooms;
+  }
+  redisInstance;
+  queueManager;
+  databaseInstance;
+  /** Redis subscriber events */
+  redisSubscriberEvents = [
+    WebSocketRedisSubscriberEvent.ClientConnected,
+    WebSocketRedisSubscriberEvent.ClientJoinedRoom,
+    WebSocketRedisSubscriberEvent.ClientLeftRoom,
+    WebSocketRedisSubscriberEvent.ClientDisconnected,
+    WebSocketRedisSubscriberEvent.DisconnectClient,
+    WebSocketRedisSubscriberEvent.SendMessage,
+    WebSocketRedisSubscriberEvent.SendMessageToAll,
+    WebSocketRedisSubscriberEvent.MessageError,
+    WebSocketRedisSubscriberEvent.QueueJobCompleted,
+    WebSocketRedisSubscriberEvent.QueueJobError,
+    WebSocketRedisSubscriberEvent.Custom
+  ];
+  constructor(props) {
+    super();
+    this.uniqueInstanceId = props.uniqueInstanceId;
+    this.applicationConfig = props.applicationConfig;
+    this.options = props.options;
+    this.redisInstance = props.redisInstance;
+    this.queueManager = props.queueManager;
+    this.databaseInstance = props.databaseInstance;
+    this.routes = props.routes;
+    this.workerId = props.workerId;
+  }
+  get type() {
+    return "server";
+  }
+  async validateWebSocketAuth(url) {
+    try {
+      const parsedUrl = new URL(url, "ws://localhost");
+      const token = parsedUrl.searchParams.get("token");
+      if (!token) {
+        return null;
+      }
+      const jwtSecretKey = this.applicationConfig.auth?.jwtSecretKey;
+      if (!jwtSecretKey) {
+        throw new Error("JWT secret key not configured");
+      }
+      const importedJwtSecretKey = await Jwt.importJwtSecretKey({
+        jwtSecretKey
+      });
+      const { payload } = await Jwt.jwtVerify(token, importedJwtSecretKey);
+      const userId = parseInt(payload.sub);
+      if (isNaN(userId)) {
+        throw new Error("Invalid user ID in token");
+      }
+      return { userId, payload };
+    } catch (error) {
+      throw new Error(`JWT verification failed: ${error.message}`);
+    }
+  }
+  async load() {
+    const libraryControllersDirectory = path.join(baseDir, "websocket", "controllers", "server");
+    await this.configureRoutes(this.defaultRoutes, libraryControllersDirectory);
+    await this.configureRoutes(this.routes, this.options.controllersDirectory);
+  }
+  async start({ fastifyServer }) {
+    return new Promise((resolve) => {
+      const server = new WS({
+        noServer: true
+        // We're handling the server externally
+      });
+      this.server = server;
+      this.handleServerStart();
+      fastifyServer.server.on("upgrade", async (request, socket, head) => {
+        if (request.url?.startsWith("/ws")) {
+          try {
+            const authenticatedUser = await this.validateWebSocketAuth(request.url);
+            server.handleUpgrade(request, socket, head, (ws) => {
+              server.emit("connection", ws, request, authenticatedUser);
+            });
+          } catch (error) {
+            log("WebSocket authentication failed", { error: error.message });
+            socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+            socket.destroy();
+          }
+        } else {
+          socket.destroy();
+        }
+      });
+      server.on("error", this.handleServerError);
+      server.on(
+        "connection",
+        (ws, request, authenticatedUser) => {
+          this.handleServerClientConnection(ws, authenticatedUser);
+        }
+      );
+      resolve({ server });
+    });
+  }
+  async stop() {
+    if (this.checkConnectedClientsInterval) {
+      clearInterval(this.checkConnectedClientsInterval);
+      this.checkConnectedClientsInterval = void 0;
+    }
+    this.redisInstance.subscriberClient?.removeListener("message", this.handleSubscriberMessage);
+    this.redisSubscriberEvents.forEach((subscriberEventName) => {
+      this.redisInstance.subscriberClient?.unsubscribe(subscriberEventName);
+    });
+    if (this.server) {
+      this.server.clients.forEach((client) => {
+        client.removeAllListeners();
+        client.close();
+      });
+      this.server.removeAllListeners();
+      this.server.close();
+    }
+    this.clientManager.cleanup();
+    this.roomManager.cleanup();
+    this.clientManager = new WebSocketClientManager();
+    this.roomManager = new WebSocketRoomManager({
+      clientManager: this.clientManager
+    });
+    log("Server stopped");
+  }
+  getControllerDependencies() {
+    return {
+      webSocketServer: this,
+      redisInstance: this.redisInstance,
+      queueManager: this.queueManager,
+      databaseInstance: this.databaseInstance
+    };
+  }
+  shouldPrintRoutes() {
+    return this.options.debug?.printRoutes ?? false;
+  }
+  handleServerStart = /* @__PURE__ */ __name(() => {
+    if (!this.server) {
+      throw new Error("WebSocket server not started");
+    }
+    if (this.options.disconnectInactiveClients?.enabled) {
+      this.checkConnectedClientsInterval = setInterval(
+        () => this.checkInactiveClients(),
+        this.options.disconnectInactiveClients.intervalCheckTime
+      );
+    }
+    this.redisSubscriberEvents.forEach((subscriberEventName) => {
+      this.redisInstance.subscriberClient?.subscribe(subscriberEventName);
+    });
+    this.redisInstance.subscriberClient.on("message", this.handleSubscriberMessage);
+    log("Server started", {
+      Host: this.options.host,
+      URL: this.options.url
+    });
+    if (this.options.events?.onServerStarted) {
+      this.options.events.onServerStarted({
+        webSocketServer: this.server
+      });
+    }
+  }, "handleServerStart");
+  /**
+   * Handle subscriber message.
+   */
+  handleSubscriberMessage = /* @__PURE__ */ __name(async (channel, message) => {
+    let parsedMessage;
+    try {
+      parsedMessage = JSON.parse(message);
+    } catch (error) {
+      log("Failed to parse subscriber message", {
+        Channel: channel,
+        Message: message,
+        Error: error
+      });
+      return;
+    }
+    const runSameWorker = parsedMessage.runSameWorker === true;
+    const isSameWorker = parsedMessage.workerId === this.workerId;
+    if (runSameWorker !== true && isSameWorker) {
+      return;
+    }
+    log("Incoming subscriber message", {
+      Channel: channel,
+      // 'Run Same Worker': parsedMessage.runSameWorker ? 'Yes' : 'No',
+      "Client ID": parsedMessage.clientId ?? "-"
+    });
+    switch (channel) {
+      case WebSocketRedisSubscriberEvent.ClientConnected: {
+        this.onClientConnect({
+          clientId: parsedMessage.clientId,
+          lastActivity: parsedMessage.lastActivity,
+          user: parsedMessage.user
+        });
+        break;
+      }
+      case WebSocketRedisSubscriberEvent.ClientDisconnected: {
+        this.onClientDisconnect({
+          clientId: parsedMessage.clientId
+        });
+        break;
+      }
+      case WebSocketRedisSubscriberEvent.DisconnectClient: {
+        const clientToDisconnect = this.clientManager.getClient({
+          clientId: parsedMessage.clientId
+          // requireWs: true,
+        });
+        log(
+          `GOT A REQUEST TO POTENTIALLY DISCONNECT LCIENT IF THIS CLIENT IS CONNETED HERE, GET CLIENT ------------------------- ${clientToDisconnect ?? "NO CLIENT"}`
+        );
+        console.log("clientToDisconnect", clientToDisconnect, "workerId: ", this.workerId);
+        if (clientToDisconnect) {
+          this.clientManager.disconnectClient({
+            clientId: parsedMessage.clientId
+          });
+          this.roomManager.removeClientFromAllRooms({
+            clientId: parsedMessage.clientId
+          });
+        }
+        break;
+      }
+      case WebSocketRedisSubscriberEvent.ClientJoinedRoom: {
+        this.onJoinRoom({
+          clientId: parsedMessage.clientId,
+          roomName: parsedMessage.roomName,
+          userData: parsedMessage.user
+        });
+        break;
+      }
+      case WebSocketRedisSubscriberEvent.ClientLeftRoom: {
+        this.roomManager.removeClientFromRoom({
+          roomName: parsedMessage.room,
+          clientId: parsedMessage.clientId
+        });
+        break;
+      }
+      case WebSocketRedisSubscriberEvent.SendMessage: {
+        break;
+      }
+      case WebSocketRedisSubscriberEvent.SendMessageToAll: {
+        this.broadcastToAllClients({ data: parsedMessage });
+        break;
+      }
+      case WebSocketRedisSubscriberEvent.MessageError: {
+        this.sendMessageError({
+          webSocketClientId: parsedMessage.clientId,
+          error: parsedMessage.error
+        });
+        break;
+      }
+      case WebSocketRedisSubscriberEvent.QueueJobCompleted: {
+        break;
+      }
+      case WebSocketRedisSubscriberEvent.QueueJobError: {
+        parsedMessage.data = parsedMessage.error;
+        break;
+      }
+      case WebSocketRedisSubscriberEvent.Custom: {
+        break;
+      }
+      default: {
+        log("Unknown subscriber message received", {
+          Channel: channel,
+          Message: message
+        });
+      }
+    }
+    if (typeof this.applicationConfig.webSocket?.subscriberEventHandler === "function") {
+      this.applicationConfig.webSocket.subscriberEventHandler({
+        channel,
+        message: parsedMessage,
+        webSocketServer: this,
+        databaseInstance: this.databaseInstance
+      });
+    }
+  }, "handleSubscriberMessage");
+  handleServerError = /* @__PURE__ */ __name((error) => {
+    Logger.error({ error });
+  }, "handleServerError");
+  handleServerClientConnection = /* @__PURE__ */ __name((ws, authenticatedUser) => {
+    const clientId = generateClientId();
+    const lastActivity = Date.now();
+    ws.on("message", (message) => this.handleClientMessage(ws, message));
+    ws.on("close", () => {
+      this.handleServerClientDisconnection(clientId);
+      this.clientManager.removeClient(clientId);
+      ws.removeAllListeners();
+    });
+    try {
+      this.clientManager.addClient({
+        clientId,
+        ws,
+        lastActivity,
+        user: authenticatedUser
+      });
+      this.redisInstance.publisherClient.publish(
+        WebSocketRedisSubscriberEvent.ClientConnected,
+        JSON.stringify({
+          clientId,
+          lastActivity,
+          workerId: this.workerId,
+          user: authenticatedUser
+        })
+      );
+      if (authenticatedUser) {
+        this.sendClientMessage(ws, {
+          type: "auth",
+          action: "authenticated",
+          data: {
+            userId: authenticatedUser.userId,
+            message: "Authentication successful"
+          }
+        });
+      }
+    } catch (error) {
+      logger.error({ error });
+    }
+  }, "handleServerClientConnection");
+  leaveRoom({ ws, roomName }) {
+    const clientId = this.clientManager.getClientId({ ws });
+    if (!clientId) {
+      log("Client ID not found when removing client from room");
+      return;
+    }
+    const clientInRoom = this.roomManager.isClientInRoom({
+      clientId,
+      roomName
+    });
+    if (!clientInRoom) {
+      log("Client not in room when removing client from room", {
+        "Client ID": clientId || "-",
+        "Room Name": roomName
+      });
+      return;
+    }
+    this.roomManager.removeClientFromRoom({
+      roomName,
+      clientId
+    });
+    this.redisInstance.publisherClient.publish(
+      WebSocketRedisSubscriberEvent.ClientLeftRoom,
+      JSON.stringify({
+        clientId,
+        room: roomName,
+        workerId: this.workerId
+      })
+    );
+    this.sendClientMessage(ws, {
+      type: "user",
+      action: "leftRoom",
+      data: {
+        roomName
+      }
+    });
+  }
+  onClientConnect({
+    clientId,
+    lastActivity,
+    user
+  }) {
+    this.clientManager.addClient({
+      clientId,
+      ws: null,
+      lastActivity,
+      user
+    });
+  }
+  onClientDisconnect({ clientId }) {
+    this.clientManager.removeClient(clientId);
+    this.roomManager.removeClientFromAllRooms({ clientId });
+  }
+  handleServerClientDisconnection = /* @__PURE__ */ __name((clientId) => {
+    const client = this.clientManager.getClient({
+      clientId
+    });
+    if (!client) {
+      log("Client not found when handling server client disconnection", {
+        "Client ID": clientId || "-"
+      });
+      return;
+    }
+    this.onClientDisconnect({ clientId });
+    this.redisInstance.publisherClient.publish(
+      WebSocketRedisSubscriberEvent.ClientDisconnected,
+      JSON.stringify({
+        clientId,
+        workerId: this.workerId
+      })
+    );
+  }, "handleServerClientDisconnection");
+  handleClientMessage = /* @__PURE__ */ __name(async (ws, message) => {
+    try {
+      const clientId = this.clientManager.getClientId({
+        ws
+      });
+      if (!clientId) {
+        log("Client ID not found when handling server message");
+        return;
+      }
+      const serverMessageResponse = await this.handleServerMessage(ws, message, clientId);
+      if (serverMessageResponse) {
+        this.sendClientMessage(ws, {
+          type: serverMessageResponse.type,
+          action: serverMessageResponse.action,
+          response: serverMessageResponse?.response
+        });
+        if (serverMessageResponse?.response?.error) {
+          Logger.error({ error: serverMessageResponse.response.error });
+        }
+      }
+    } catch (error) {
+      Logger.error({ error });
+      log("Error handling client message", {
+        Error: error
+      });
+    }
+  }, "handleClientMessage");
+  handleMessageError(clientId, error) {
+    this.redisInstance.publisherClient.publish(
+      WebSocketRedisSubscriberEvent.MessageError,
+      JSON.stringify({
+        runSameWorker: true,
+        clientId,
+        error
+      })
+    );
+  }
+  checkInactiveClients() {
+    if (this.options.disconnectInactiveClients?.enabled && this.options.disconnectInactiveClients.log) {
+      log("Checking inactive clients...");
+    }
+  }
+  // private disconnectClient({
+  //   clientId,
+  // }: {
+  //   clientId: string;
+  // }) {
+  //   const clientInfo = this.connectedClients.get(clientId);
+  //   if (clientInfo?.ws) {
+  //     const connectedTime =
+  //       Date.now() - clientInfo.lastActivity;
+  //     clientInfo.ws.close();
+  //     Logger.info(
+  //       'WebSocket client was disconnected due to inactivity',
+  //       {
+  //         ID: clientId,
+  //         Worker: this.workerId,
+  //         'Time Connected': Time.formatTime({
+  //           time: connectedTime,
+  //           format: 's',
+  //         }),
+  //       },
+  //     );
+  //   }
+  // }
+  broadcastToAllClients({
+    data,
+    excludeClientId
+  }) {
+    if (!this.server) {
+      log("Server not started when broadcasting to all clients");
+      return;
+    }
+    this.server.clients.forEach((client) => {
+      let excludeClient = false;
+      if (excludeClientId) {
+        const clientId = this.clientManager.getClientId({
+          ws: client
+        });
+        excludeClient = clientId === excludeClientId;
+      }
+      if (client.readyState === WebSocket.OPEN && !excludeClient) {
+        client.send(JSON.stringify(data));
+      }
+    });
+  }
+  sendMessageError({ webSocketClientId, error }) {
+    const client = this.clientManager.getClient({
+      clientId: webSocketClientId
+    });
+    if (!client) {
+      log("Client not found when sending message error", {
+        "Client ID": webSocketClientId || "-",
+        Error: error
+      });
+      return;
+    } else if (!client.ws) {
+      log("Client WebSocket not found when sending message error", {
+        "Client ID": webSocketClientId || "-",
+        Error: error
+      });
+      return;
+    }
+    this.sendClientMessage(client.ws, {
+      type: "error",
+      action: "message",
+      data: {
+        error
+      }
+    });
+  }
+  // private getClientId({
+  //   client,
+  // }: {
+  //   client: WebSocket;
+  // }): string | undefined {
+  //   return [...this.connectedClients.entries()].find(
+  //     ([_, value]) => value.ws === client,
+  //   )?.[0];
+  // }
+  onJoinRoom({ clientId, roomName, userData }) {
+    const client = this.clientManager.getClient({
+      clientId
+    });
+    if (!client) {
+      log("Client not found when joining room", {
+        "Client ID": clientId || "-",
+        "Room Name": roomName
+      });
+      return;
+    }
+    const clientCanJoinMultipleRooms = false;
+    if (clientCanJoinMultipleRooms !== true) {
+      if (client.roomName) {
+        this.roomManager.removeClientFromRoom({
+          roomName: client.roomName,
+          clientId
+        });
+      }
+    }
+    this.clientManager.updateClient({
+      clientId,
+      key: "user",
+      data: userData
+    });
+    this.roomManager.addClientToRoom({
+      clientId,
+      user: userData,
+      roomName
+    });
+  }
+  async joinRoom({
+    ws,
+    userId,
+    userType,
+    username,
+    roomName
+  }) {
+    const clientId = this.clientManager.getClientId({ ws });
+    if (!clientId) {
+      logger.warn({
+        message: "Client ID not found when joining room",
+        meta: {
+          // 'WebSocket ID': ws?.id || '-',
+          "Room Name": roomName
+        }
+      });
+      return;
+    }
+    const isClientInRoom = this.roomManager.isClientInRoom({
+      clientId,
+      roomName
+    });
+    if (isClientInRoom) {
+      logger.warn({
+        message: "Client already in room when joining",
+        meta: {
+          // 'WebSocket ID': ws?. || '-',
+          "Room Name": roomName,
+          "Client ID": clientId
+        }
+      });
+      return;
+    }
+    let userData = {};
+    if (userId) {
+      const dbEntityManager = this.databaseInstance.getEntityManager();
+      const getUserQuery = "SELECT email FROM users WHERE id = ?";
+      const getUserParams = [userId];
+      const getUserResult = await dbEntityManager.execute(getUserQuery, getUserParams);
+      if (!getUserResult || getUserResult.length === 0) {
+        throw new Error("User not found in database");
+      }
+      const user = getUserResult[0];
+      userData = {
+        id: userId,
+        ...user
+      };
+    }
+    if (username) {
+      userData.username = username;
+    }
+    userData.userType = userType;
+    this.onJoinRoom({
+      clientId,
+      roomName,
+      userData
+    });
+    this.redisInstance.publisherClient.publish(
+      WebSocketRedisSubscriberEvent.ClientJoinedRoom,
+      JSON.stringify({
+        clientId,
+        user: userData,
+        roomName,
+        workerId: this.workerId
+      })
+    );
+    return true;
+  }
+  sendClientMessage = /* @__PURE__ */ __name((ws, data, binary = false) => {
+    const webSocketMessage = JSON.stringify(data);
+    ws.send(webSocketMessage, { binary });
+  }, "sendClientMessage");
+  sendMessage = /* @__PURE__ */ __name(({ data }) => {
+    const formattedData = {
+      ...data,
+      workerId: this.workerId
+    };
+    this.redisInstance.publisherClient.publish(
+      WebSocketRedisSubscriberEvent.SendMessage,
+      JSON.stringify(formattedData)
+    );
+  }, "sendMessage");
+  sendMessageToAll = /* @__PURE__ */ __name(({ data }) => {
+    const formattedData = {
+      ...data,
+      workerId: this.workerId
+    };
+    this.redisInstance.publisherClient.publish(
+      WebSocketRedisSubscriberEvent.SendMessageToAll,
+      JSON.stringify(formattedData)
+    );
+  }, "sendMessageToAll");
+  sendCustomMessage = /* @__PURE__ */ __name(({ data }) => {
+    const formattedData = {
+      ...data,
+      workerId: this.workerId
+    };
+    console.log("SEND CUSTOM MESSAGE:", formattedData);
+    this.redisInstance.publisherClient.publish(WebSocketRedisSubscriberEvent.Custom, JSON.stringify(formattedData));
+  }, "sendCustomMessage");
+  getClients({ userType }) {
+    return this.clientManager.getClients({ userType });
+  }
+}
+export {
+  WebSocketServer as default
+};
+//# sourceMappingURL=websocket-server.js.map