@nsshunt/stsuxvue 1.0.55 → 1.0.57

package/dist/stsuxvue.mjs

@@ -2,13 +2,13 @@ import { defineStore } from "pinia";
 import _cloneDeep from "lodash.clonedeep";
 import { defineComponent, defineAsyncComponent, ref, createElementBlock, openBlock, createVNode, unref, reactive, computed, watch, resolveComponent, createBlock, withCtx, createTextVNode, toDisplayString, createElementVNode, createCommentVNode, Fragment, renderList, onMounted, onBeforeUnmount, resolveDynamicComponent, isRef } from "vue";
 import { Gauge, ObservabilitySocketIOSubscriber, ObservabilityRESTAPISubscriber, ObservabilitySubscriptionManager, SubscriptionTopic } from "@nsshunt/stsobservability";
-import { defaultLogger } from "@nsshunt/stsutils";
+import { Sleep, defaultLogger } from "@nsshunt/stsutils";
 import { io } from "socket.io-client";
-import "socket.io";
-import "ioredis";
+import { Server } from "socket.io";
+import { Redis } from "ioredis";
 import require$$0$2 from "node:cluster";
 import require$$1$2 from "socket.io-adapter";
-import "@socket.io/redis-streams-adapter";
+import { createAdapter } from "@socket.io/redis-streams-adapter";
 var _estate = /* @__PURE__ */ ((_estate2) => {
   _estate2["IDLE"] = "idle";
   _estate2["STARTING"] = "starting";
@@ -9996,7 +9996,61 @@ function v4(options, buf, offset) {
   return _v4(options);
 }
 const isNode = Object.prototype.toString.call(typeof process !== "undefined" ? process : 0) === "[object process]";
-class SocketIoClient {
+var tinyEmitter$1 = { exports: {} };
+var hasRequiredTinyEmitter$1;
+function requireTinyEmitter$1() {
+  if (hasRequiredTinyEmitter$1) return tinyEmitter$1.exports;
+  hasRequiredTinyEmitter$1 = 1;
+  function E() {
+  }
+  E.prototype = {
+    on: function(name, callback, ctx) {
+      var e = this.e || (this.e = {});
+      (e[name] || (e[name] = [])).push({
+        fn: callback,
+        ctx
+      });
+      return this;
+    },
+    once: function(name, callback, ctx) {
+      var self = this;
+      function listener() {
+        self.off(name, listener);
+        callback.apply(ctx, arguments);
+      }
+      listener._ = callback;
+      return this.on(name, listener, ctx);
+    },
+    emit: function(name) {
+      var data = [].slice.call(arguments, 1);
+      var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
+      var i = 0;
+      var len = evtArr.length;
+      for (i; i < len; i++) {
+        evtArr[i].fn.apply(evtArr[i].ctx, data);
+      }
+      return this;
+    },
+    off: function(name, callback) {
+      var e = this.e || (this.e = {});
+      var evts = e[name];
+      var liveEvents = [];
+      if (evts && callback) {
+        for (var i = 0, len = evts.length; i < len; i++) {
+          if (evts[i].fn !== callback && evts[i].fn._ !== callback)
+            liveEvents.push(evts[i]);
+        }
+      }
+      liveEvents.length ? e[name] = liveEvents : delete e[name];
+      return this;
+    }
+  };
+  tinyEmitter$1.exports = E;
+  tinyEmitter$1.exports.TinyEmitter = E;
+  return tinyEmitter$1.exports;
+}
+var tinyEmitterExports$1 = requireTinyEmitter$1();
+class SocketIoClient extends tinyEmitterExports$1.TinyEmitter {
   #agentManager;
   #logger;
   #name;
@@ -10005,6 +10059,7 @@ class SocketIoClient {
   #authToken;
   #socket;
   constructor(name) {
+    super();
     this.#name = name;
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -10072,13 +10127,15 @@ class SocketIoClient {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   ErrorCallBack(error) {
   }
-  emit(ev, ...args) {
-    if (this.#socket) {
-      return this.#socket.emit(ev, ...args);
-    } else {
-      throw new Error("SocketIoClient:emit(): Error: [socket instance not defined.]");
-    }
+  /*
+  emit<Ev extends EventNames<ClientToServerEvents>>(ev: Ev, ...args: EventParams<ClientToServerEvents, Ev>): Socket<ServerToClientEvents, ClientToServerEvents> {
+      if (this.#socket) {
+          return this.#socket!.emit(ev, ...args);
+      } else {
+          throw new Error('SocketIoClient:emit(): Error: [socket instance not defined.]');
+      }
   }
+  */
   #EstablishSocketConnect() {
     if (this.#socket !== void 0) {
       if (this.#socket.connected === true) {
@@ -10746,7 +10803,322 @@ function requireDist() {
   }
   return dist;
 }
-requireDist();
+var distExports = requireDist();
+class SocketIoServer extends tinyEmitterExports$1.TinyEmitter {
+  namespace;
+  socketionamespace;
+  //protected socketionamespace?: Namespace<ClientToServerEvents, ServerToClientEvents, InterServerEvents>
+  logger;
+  io;
+  //#redisClient: RedisClientType | Redis | null = null;
+  redisClient;
+  listenPort;
+  socketIoCustomPath;
+  ioRedisMessageProcessorUrl;
+  serverClusterMode;
+  rooms;
+  constructor() {
+    super();
+  }
+  LogErrorMessage(message) {
+    if (this.logger) {
+      this.logger.error(`${this.namespace}: ${message}`);
+    }
+  }
+  LogDebugMessage(message) {
+    if (this.logger) {
+      this.logger.debug(`${this.namespace}: ${message}`);
+    }
+  }
+  LogInfoMessage(message) {
+    if (this.logger) {
+      this.logger.info(`${this.namespace}: ${message}`);
+    }
+  }
+  LogWarnMessage(message) {
+    if (this.logger) {
+      this.logger.warn(`${this.namespace}: ${message}`);
+    }
+  }
+  // https://socket.io/docs/v4/middlewares/
+  // https://socket.io/docs/v4/server-socket-instance/#sockethandshake
+  // https://socket.io/docs/v4/server-socket-instance/#socket-middlewares
+  // Use this middleward to check every incomming connection
+  SetupConnectionMiddleware = () => {
+  };
+  // Use this middleware to check every packet being received
+  SetupMessageMiddleware = (socket) => {
+  };
+  SocketConnectCallBack = (socket) => {
+  };
+  SocketEventsCallBack = (socket) => {
+  };
+  GetConfig = (socketIoServeroptions) => {
+    const options = {
+      transports: ["websocket"]
+      // or [ "websocket", "polling" ] (to use long-poolling. Note that the order matters)
+    };
+    if (socketIoServeroptions.ioRedisMessageProcessorUrl && socketIoServeroptions.ioRedisMessageProcessorUrl !== "") {
+      this.redisClient = new Redis(socketIoServeroptions.ioRedisMessageProcessorUrl);
+      options.adapter = createAdapter(this.redisClient);
+    } else if (socketIoServeroptions.serverClusterMode && socketIoServeroptions.serverClusterMode === true) {
+      options.adapter = distExports.createAdapter();
+    }
+    if (socketIoServeroptions.wssCustomPath && socketIoServeroptions.wssCustomPath.localeCompare("") !== 0) {
+      options.path = socketIoServeroptions.wssCustomPath;
+    }
+    return options;
+  };
+  SetEngineEvents = () => {
+    if (this.io) {
+      this.io.engine.on("connection_error", (err) => {
+        this.LogInfoMessage(err.req);
+        this.LogInfoMessage(err.code);
+        this.LogInfoMessage(err.message);
+        this.LogInfoMessage(err.context);
+      });
+    }
+  };
+  WithLogger = (logger) => {
+    this.logger = logger;
+    return this;
+  };
+  WithExistingServer = (server) => {
+    if (this.io) {
+      throw new Error(`SocketIoServer:AttachServer(): Error: [Server already attached]`);
+    }
+    this.io = server;
+    return this;
+  };
+  WithListenPort = (listenPort) => {
+    this.listenPort = listenPort;
+    return this;
+  };
+  WithSocketIoCustomPath = (socketIoCustomPath) => {
+    this.socketIoCustomPath = socketIoCustomPath;
+    return this;
+  };
+  WithIoRedisMessageProcessorUrl = (ioRedisMessageProcessorUrl) => {
+    this.ioRedisMessageProcessorUrl = ioRedisMessageProcessorUrl;
+    return this;
+  };
+  WithClusterMode = (serverClusterMode) => {
+    this.serverClusterMode = serverClusterMode;
+    return this;
+  };
+  WithRooms = (rooms) => {
+    this.rooms = rooms;
+    return this;
+  };
+  WithNamespace = (namespace) => {
+    this.namespace = namespace;
+    return this;
+  };
+  StartServer = async () => {
+    if (!this.namespace) {
+      throw new Error(`SocketIoServer:StartServer(): Error: [namespace not specified]`);
+    }
+    if (!this.io) {
+      if (!this.listenPort) {
+        throw new Error(`SocketIoServer:StartServer(): Error: [listenPort not specified]`);
+      }
+      const options = {
+        transports: ["websocket"]
+        // or [ "websocket", "polling" ] (to use long-poolling. Note that the order matters)
+      };
+      if (this.ioRedisMessageProcessorUrl && this.ioRedisMessageProcessorUrl !== "") {
+        this.redisClient = new Redis(this.ioRedisMessageProcessorUrl);
+        options.adapter = createAdapter(this.redisClient);
+      } else if (this.serverClusterMode && this.serverClusterMode === true) {
+        options.adapter = distExports.createAdapter();
+      }
+      if (this.socketIoCustomPath && this.socketIoCustomPath.localeCompare("") !== 0) {
+        options.path = this.socketIoCustomPath;
+      }
+      this.io = new Server(this.listenPort, options);
+      this.SetEngineEvents();
+      await Sleep(500);
+    }
+    let autoJoinRooms;
+    let rooms;
+    if (this.rooms && this.rooms.length > 0) {
+      autoJoinRooms = true;
+      rooms = [...this.rooms];
+    } else {
+      autoJoinRooms = false;
+      rooms = [];
+    }
+    this.SetupNamespace(rooms, autoJoinRooms);
+    return this;
+  };
+  AttachServer = async (server) => {
+    if (this.io) {
+      throw new Error(`SocketIoServer:AttachServer(): Error: [Server already attached]`);
+    }
+    this.io = server;
+  };
+  StopServer = async () => {
+    if (this.io) {
+      await this.CloseNamespaceAdaptors();
+      this.DisconnectNamespaceSockets();
+      await this.io.of("/").adapter.close();
+      if (this.redisClient) {
+        await this.redisClient.disconnect();
+        await Sleep(50);
+      }
+      this.io.disconnectSockets();
+      this.io = void 0;
+    }
+  };
+  LeaveRoom = (socket, room) => {
+    this.LogDebugMessage(`Leaving room [${room}]`);
+    socket.leave(room);
+  };
+  JoinRoom = (socket, room) => {
+    this.LogDebugMessage(`Socket joining room [${room}], ID: [${socket.id}]`);
+    socket.join(room);
+  };
+  SetupStandardEvents = (socket) => {
+    socket.on("disconnect", (reason) => {
+      this.LogDebugMessage(`socket disconnect, ID: [${socket.id}] [${reason}]`);
+    });
+    socket.on("disconnecting", (reason) => {
+      this.LogDebugMessage(`socket disconnecting, ID: [${socket.id}] [${reason}]`);
+    });
+    socket.on("error", (error) => {
+      this.LogDebugMessage(`socket error, ID: [${socket.id}] [${error}]`);
+    });
+    socket.on("__STSdisconnect", (reason) => {
+      this.LogDebugMessage(`__STSdisconnect: socket disconnect, ID: [${socket.id}] [${reason}]`);
+    });
+    socket.on("__STSdisconnecting", (reason, callBackResult) => {
+      this.LogDebugMessage(`__STSdisconnecting: socket disconnecting, ID: [${socket.id}] [${reason}]`);
+      callBackResult("__STSdisconnecting accepted by server.");
+    });
+    socket.on("__STSjoinRoom", (rooms) => {
+      rooms.forEach((room) => {
+        this.JoinRoom(socket, room);
+      });
+    });
+    socket.on("__STSleaveRoom", (rooms) => {
+      rooms.forEach((room) => {
+        this.LeaveRoom(socket, room);
+      });
+    });
+    socket.on("__STSsendToRoom", (rooms, payload) => {
+      rooms.forEach((room) => {
+        if (this.socketionamespace) {
+          this.LogDebugMessage(`socket.on: __STSsendToRoom: Sending to room [${room}], ID: [${socket.id}]`);
+          this.socketionamespace.to(room).emit(payload.command, payload);
+        }
+      });
+    });
+    socket.on("__STSsendToRoomWithCallback", (room, timeout, payload, cb) => {
+      if (this.socketionamespace) {
+        this.socketionamespace.to(room).timeout(timeout).emit(payload.command, payload, (err, dataResponse) => {
+          if (err) {
+            console.error(err);
+            const errorResponse = {
+              error: true,
+              errorName: err.name,
+              errorMessage: err.message
+              //errorCause: err.cause,
+              //errorStack: err.stack
+            };
+            this.LogErrorMessage(`__STSsendToRoomWithCallback broadcast (error): [${JSON.stringify(errorResponse)}]`);
+            cb(errorResponse);
+          } else {
+            this.LogDebugMessage(`__STSsendToRoomWithCallback broadcast: [${JSON.stringify(dataResponse)}]`);
+            cb(dataResponse);
+          }
+        });
+      }
+    });
+    socket.on("__STSsendToRoomsWithCallback", (rooms, timeout, payload, cb) => {
+      const responses = [];
+      const timeoutForComplete = setTimeout(() => {
+        responses.push({
+          room: "",
+          responses: {
+            error: true,
+            errorName: "timeout",
+            errorMessage: `__STSsendToRoomsWithCallback timeout: [${timeout}] before all responses received`
+          }
+        });
+        cb(responses);
+      }, timeout).unref();
+      rooms.forEach((room) => {
+        if (this.socketionamespace) {
+          this.socketionamespace.to(room).timeout(timeout).emit(payload.command, payload, (err, dataResponse) => {
+            if (err) {
+              console.error(err);
+              const errorResponse = {
+                error: true,
+                errorName: err.name,
+                errorMessage: err.message
+                //errorCause: err.cause,
+                //errorStack: err.stack
+              };
+              this.LogErrorMessage(`__STSsendToRoomWithCallback broadcast (error): [${JSON.stringify(errorResponse)}]`);
+              responses.push({
+                room,
+                responses: errorResponse
+              });
+            } else {
+              this.LogDebugMessage(`__STSsendToRoomWithCallback broadcast: [${JSON.stringify(dataResponse)}]`);
+              responses.push({
+                room,
+                responses: dataResponse
+              });
+            }
+            if (responses.length === rooms.length) {
+              clearTimeout(timeoutForComplete);
+              cb(responses);
+            }
+          });
+        }
+      });
+    });
+  };
+  SetupNamespace = (rooms, autoJoinRooms) => {
+    if (this.io) {
+      this.socketionamespace = this.io.of(`/${this.namespace}/`);
+      this.SetupConnectionMiddleware();
+      this.socketionamespace.on("connection", (socket) => {
+        this.LogDebugMessage(`Socket connected, ID: [${socket.id}]`);
+        this.LogDebugMessage(`Authentication Handshake (auth): [${JSON.stringify(socket.handshake.auth)}]`);
+        this.LogDebugMessage(`Authentication Handshake (host): [${JSON.stringify(socket.handshake.headers.host)}]`);
+        this.LogDebugMessage(`Authentication Handshake (url): [${JSON.stringify(socket.handshake.url)}]`);
+        this.LogDebugMessage(`Authentication Handshake: [${JSON.stringify(socket.handshake)}]`);
+        this.SetupMessageMiddleware(socket);
+        if (autoJoinRooms) {
+          rooms.map((room) => {
+            this.JoinRoom(socket, room);
+          });
+        }
+        this.SetupStandardEvents(socket);
+        setTimeout(() => {
+          this.SocketConnectCallBack(socket);
+        }, 0);
+        this.SocketEventsCallBack(socket);
+      });
+    } else {
+      throw new Error("SocketIoServer:SetupNamespace(): Error: [No server attached");
+    }
+    return this;
+  };
+  CloseNamespaceAdaptors = async () => {
+    if (this.socketionamespace) {
+      await this.socketionamespace.adapter.close();
+    }
+  };
+  DisconnectNamespaceSockets = () => {
+    if (this.socketionamespace) {
+      this.socketionamespace.disconnectSockets();
+      this.socketionamespace = void 0;
+    }
+  };
+}
 var tinyEmitter = { exports: {} };
 var hasRequiredTinyEmitter;
 function requireTinyEmitter() {