ff-admin/src/socketManager.ts

import { Manager, Socket } from "socket.io-client";
import { refreshToken, url } from "./serverCom";
import { useNotificationStore } from "./stores/notification";
import { SocketConnectionTypes } from "./enums/socketEnum";

export abstract class SocketManager {
  private static readonly manager = new Manager(url, {
    reconnection: true,
    reconnectionDelayMax: 10000,
  });
  private static readonly connections = new Map<SocketConnectionTypes, Socket>();

  public static establishConnection(
    connection: SocketConnectionTypes,
    restoreAfterDisconnect: boolean = false
  ): Socket {
    const existingSocket = this.connections.get(connection);
    if (existingSocket !== undefined && existingSocket.connected) return existingSocket!;

    existingSocket?.removeAllListeners();

    const notificationStore = useNotificationStore();
    let socket = this.manager.socket(connection, {
      auth: (cb) => {
        cb({ token: localStorage.getItem("accessToken") });
      },
    });
    socket.on("connect", () => {
      notificationStore.push("Socket-Erfolg", `Verbindung aufgebaut`, "success");
    });
    socket.on("connect_error", (err) => {
      this.socketHandleError(connection, err, true);
    });
    socket.on("disconnect", () => {
      if (restoreAfterDisconnect) this.establishConnection(connection);
      else notificationStore.push("Socket", `Verbindung getrennt`, "info");
    });
    socket.on("warning", (msg: string) => {
      notificationStore.push("Socket-Warnung", msg, "warning");
    });
    socket.on("error", (msg: string) => {
      this.socketHandleError(connection, {
        name: "Error",
        message: msg,
      });
    });

    this.connections.set(connection, socket);
    return socket;
  }

  public static getConnection(connection: SocketConnectionTypes) {
    return this.connections.get(connection);
  }

  public static closeConnection(connection: SocketConnectionTypes) {
    let socket = this.connections.get(connection);
    if (socket) {
      socket.disconnect();
      this.connections.delete(connection);
    }
  }

  private static socketHandleError(connection: SocketConnectionTypes, err: Error, onConnect = false) {
    const notificationStore = useNotificationStore();

    if (err.message == "xhr poll error") {
      notificationStore.push("Socket-Netzwerk-Fehler", "Reconnect Versuch in 10s", "error");
    } else if (err.message == "Token expired") {
      notificationStore.push("Session", "Session wird verlängert", "info");
      refreshToken()
        .then(() => {
          notificationStore.push("Session", "Session erfolgreich verlängert", "success");
          this.closeConnection(connection);
        })
        .catch(() => {
          notificationStore.push("Session-Fehler", "Anmeldung wurde nicht verlängert", "error");
        });
    } else if (onConnect) {
      notificationStore.push("Socket-Fehler", `Verbindung fehlgeschlagen`, "error");
    } else {
      notificationStore.push("Socket-Fehler", err.message, "error");
    }
  }
}