@nsshunt/stsappframework 3.0.104 → 3.0.106

package/src_working2/serverprocessbase.ts

@@ -1,393 +0,0 @@
-/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
-import debugModule from 'debug'
-const debug = debugModule(`proc:${process.pid}`);
-
-import { $Options } from '@nsshunt/stsconfig'
-const goptions = $Options()
-
-import fs from "fs"
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import colors from 'colors'
-
-import { createAdapter as clusterCreateAdapter } from '@socket.io/cluster-adapter'
-import { createAdapter } from "@socket.io/redis-streams-adapter";
-
-import { JSONObject, Sleep } from '@nsshunt/stsutils'
-
-import { ProcessOptions, STSServerType } from './processoptions'
-import { ProcessBase } from './processbase';
-
-import { register, Counter, collectDefaultMetrics, AggregatorRegistry } from 'prom-client'
-
-import { createServer as createServerHttps } from 'https'
-import { createServer } from 'http'
-import tls from 'node:tls'
-import net from 'node:net'
-
-import { Server, ServerOptions } from "socket.io";
-import { STSExpressServer } from './server';
-import { Express } from 'express'
-
-import { createClient, RedisClientType } from 'redis';
-
-import jayson from 'jayson'
-
-/**
- * todo
- * @typedef {Object} options - todo
- * @property {boolean} [wssServer=false] - Create a web socket server on this worker instance
- */
-export class ServerProcessBase extends ProcessBase
-{
-    #masterProcessExitTime = goptions.masterProcessExitTime;
-    #io: Server | null = null;
-    #redisClient: RedisClientType | null = null;
-    #httpServer: any = null;
-    #expressServer: STSExpressServer | null = null;
-    #sockets: net.Socket[] = [ ];
-    #shuttingDown = false;
-
-    constructor(options: ProcessOptions) {
-        super(options);
-    }
-
-    get httpServer() {
-        return this.#httpServer;
-    }
-
-    get io() {
-        return this.#io;
-    }
-
-    get expressServer(): STSExpressServer | null {
-        return this.#expressServer;
-    }
-    set expressServer(val: STSExpressServer | null) {
-        this.#expressServer = val;
-    }
-
-    // Setup server to Prometheus scrapes:
-    #SetupPrometheusEndPoints = (expressServer: Express) => {
-        // AggregatorRegistry is required here in the worker as well as the master in order for prom-client to work correctly.
-        new AggregatorRegistry();
-
-        const prefix = 'sts_';
-
-        collectDefaultMetrics({
-            labels: { NODE_APP_INSTANCE: process.pid },
-            prefix: prefix
-        });
-
-        const c = new Counter({
-            name: 'sts_test_counter',
-            help: 'Example of a counter',
-            labelNames: ['code'],
-        });
-
-        setInterval(() => {
-            c.inc({ code: 200 });
-        }, 1000).unref();
-
-        setInterval(() => {
-            c.inc({ code: 400 });
-            c.inc({ code: 'worker_' + process.pid });
-        }, 500).unref();
-
-        expressServer.get('/metrics', async (req: any, res: any) => {
-            try {
-                res.set('Content-Type', register.contentType);
-                res.end(await register.metrics());
-            } catch (ex) {
-                res.status(500).end(ex);
-            }
-        });
-
-        expressServer.get('/metrics/counter', async (req: any, res: any) => {
-            try {
-                res.set('Content-Type', register.contentType);
-                res.end(await register.getSingleMetricAsString('test_counter'));
-            } catch (ex) {
-                res.status(500).end(ex);
-            }
-        });
-    }
-
-    #SetupTLSServer = async (socket: net.Socket): Promise<void> => {
-        // Add a 'close' event handler to this instance of socket
-        console.log('CONNECTED: ' + socket.remoteAddress + ':' + socket.remotePort + ' ' + process.pid);
-        this.#sockets.push(socket);
-
-        //const self = this;
-        socket.on('close', (data: any) => {
-            const index = this.#sockets.findIndex(function(o) {
-                return o.remoteAddress === socket.remoteAddress && o.remotePort === socket.remotePort;
-            })
-            if (index !== -1) this.#sockets.splice(index, 1);
-            console.log('CLOSED: ' + socket.remoteAddress + ' ' + socket.remotePort + ' ' + process.pid);
-        });
-
-        socket.on('data', function(data: any) {
-            console.log('DATA ' + socket.remoteAddress + ': ' + socket.remotePort + ': ' + data);
-            socket.write(socket.remoteAddress + ':' + socket.remotePort + " said " + data + '\n');
-
-            // Write the data back to all the connected, the client will receive it as data from the server
-            /*
-            self.#sockets.forEach(function(socket, index, array) {
-                socket.write(socket.remoteAddress + ':' + socket.remotePort + " said " + data + '\n');
-            });
-
-            */
-        });
-    }
-
-    #SetupRPCServer = async (socket: net.Socket): Promise<void> => {
-        console.log('CONNECTED: ' + socket.remoteAddress + ':' + socket.remotePort + ' ' + process.pid);
-
-        socket.on('close', function(data: any) {
-            console.log('CLOSED: ' + socket.remoteAddress + ' ' + socket.remotePort + ' ' + process.pid);
-        });
-
-        socket.on('data', function(data: any) {
-            console.log('DATA ' + socket.remoteAddress + ': ' + data);
-        });
-    }
-
-    #SetupWSSServer = async (): Promise<void> => {
-        // socket.io
-        // WebSocket
-        const options: Partial<ServerOptions> = {
-            transports: [ "websocket" ] // or [ "websocket", "polling" ] (to use long-poolling. Note that the order matters)
-            // The default path is /socket.io
-            // This can be changed with the path option as shown below
-            //,path: '/zzz'
-        };
-
-        //this.#io = require("socket.io")(this.#httpServer, options);
-        this.#io = new Server(this.#httpServer, options);
-
-        if (this.options.clusterMode) {
-            if (this.options.useRedisAdaptor) {
-                this.LogEx(`Using Redis for socket.io cluster management (worker)`);
-                if (this.options.redisAdaptorUrl) {
-                    this.LogEx(`Redis url: [${this.options.redisAdaptorUrl}]`);
-                    this.#redisClient = createClient({url: this.options.redisAdaptorUrl});
-                } else {
-                    this.LogEx(`Redis url: [localhost]`);
-                    this.#redisClient = createClient();
-                }
-                await this.#redisClient.connect();
-                this.#io.adapter(createAdapter(this.#redisClient) as any);
-                this.LogEx(`Redis successfully connected.`);
-            } else {
-                this.#io.adapter(clusterCreateAdapter() as any);
-                this.LogEx(`Using nodejs cluster mode for socket.io cluster management`);
-            }
-        } else {
-            this.LogEx(`Not using any adaptors for socket.io cluster management.}`);
-        }
-
-        // To use a seperate socket server, the code below can be applied.
-        // this.#io = require("socket.io")(options);
-        // this.#io.adapter(createAdapter());
-        // this.#io.listen(3006);
-        // LogEx(`socket.io init`);
-
-        this.#io.engine.on("connection_error", (err) => {
-            this.LogEx(err.req); // the request object
-            this.LogEx(err.code); // the error code, for example 1
-            this.LogEx(err.message); // the error message, for example "Session ID unknown"
-            this.LogEx(err.context); // some additional error context
-        });
-    }
-
-    #GetTLSOptions = (): JSONObject => {
-        return {
-            key: fs.readFileSync(this.options.httpsServerKeyPath),
-            cert: fs.readFileSync(this.options.httpsServerCertificatePath)
-        };
-    }
-
-    #SetupExpressServer = async (useTls: boolean): Promise<void> => {
-        if (useTls) {
-            this.#httpServer = createServerHttps(this.#GetTLSOptions(), (this.#expressServer as STSExpressServer).App);
-        } else {
-            this.#httpServer = createServer((this.#expressServer as STSExpressServer).App);
-        }
-        if (this.options.prometheusSupport === true) {
-            this.#SetupPrometheusEndPoints((this.#expressServer as STSExpressServer).App);
-        }
-        if (this.options.wssServer === true) {
-            await this.#SetupWSSServer();
-        }
-        // https://stackoverflow.com/questions/21342828/node-express-unix-domain-socket-permissions
-        //@@httpServer.listen('/tmp/stsrest01.sock').on('listening', () =>
-        //@@httpServer.listen('/var/run/sts/stsrest01.sock').on('listening', () =>
-        this.#httpServer.listen(this.options.listenPort, () => { 
-            //@@chmodSync(this.options.port, 511);
-        }).on('listening', () =>
-        {
-            this.LogEx(`live on ${this.options.endpoint}:${this.options.listenPort}${this.options.apiRoot}`);
-        });
-    }
-
-    #SetupTCPRawServer = async (): Promise<void> => {
-        // The second parameter is the automatic listener for the secureConnection event from the tls.Server class
-        this.#httpServer = tls.createServer(this.#GetTLSOptions(), this.#SetupTLSServer);
-        this.#httpServer.listen(this.options.listenPort, 'stscore.stsmda.org', () => { 
-            console.log('TCP Server is running on port ' + this.options.listenPort + '.');
-        }).on('listening', () =>
-        {
-            this.LogEx(`TCP live on ${this.options.endpoint}:${this.options.listenPort}${this.options.apiRoot}`);
-        });
-    }
-
-    #SetupJSONRPCServer = async (): Promise<void> => {
-        const jaysonServer = new jayson.server();
-        // Supported methods here - move somewhere else ...
-        jaysonServer.method("add", function(args: any, callback: any) {
-            callback(null, args[0] + args[1]);
-        });
-        this.#httpServer = jaysonServer.tls(this.#GetTLSOptions());
-        (this.#httpServer as tls.Server).on('secureConnection', this.#SetupRPCServer);
-        this.#httpServer.listen(this.options.listenPort, 'stscore.stsmda.org', () => { 
-            console.log('JSON RPC 2.0 Server is running on port ' + this.options.listenPort + '.');
-        }).on('listening', () =>
-        {
-            this.LogEx(`JSON RPC 2.0 live on ${this.options.endpoint}:${this.options.listenPort}${this.options.apiRoot}`);
-        });
-    }
-
-    ProcessTerminating = async (): Promise<void> => {
-        return;
-    }
-
-    override get shuttingDown(): boolean {
-        return this.#shuttingDown;
-    }
-
-    // Terminate in order;
-    // forked worker threads (send signal)
-    // De-Register service
-    // systeminformation observers
-    // instrument timers (gauge etc.)
-    // publisher
-    // terminate UI (if loaded)
-    Terminate = async (clusterPerformExit: boolean, signal?: any): Promise<void> => {
-        if (this.#shuttingDown === false) {
-            this.#shuttingDown = true;
-
-            await this.ProcessTerminate();
-
-            await this.ProcessTerminating();
-
-            if (!this.options.clusterMode) {
-                if (this.GetUIController() !== null)
-                {
-                    this.LogEx('Destroy the user interface controller.');
-                    this.GetUIController().DestroyUI();
-                }
-        
-                if (signal) {
-                    this.LogEx(this.GetSignalColour(signal)(`Main Process (singleprocess): ${process.pid} received signal: ${signal}`));
-                } else {
-                    this.LogEx(this.GetSignalColour(null)(`Main Process (singleprocess): ${process.pid} received Terminate without signal.`));
-                }
-            }
-
-            if (this.options.wssServer === true && this.#io !== null)
-            {
-                this.LogEx(`Disconnect Sockets.`);
-                if (this.socketIoServerHelper !== null) {
-                    this.socketIoServerHelper.DisconnectSockets();
-                } else {
-                    this.#io.disconnectSockets();
-                }
-                this.socketIoServerHelper = null;
-                this.#io = null;
-                // Note that this.#redisClient.disconnect() is not required becuase DisconnectSockets performs this action.
-            }
-
-            if (this.#httpServer) {
-                if (this.options.serverType === STSServerType.TCPRAW_TLS) {
-                    this.#sockets.forEach((socket: net.Socket, index, array) => {
-                        this.LogEx(`TCP Socket destroy, remote address: [${socket.remoteAddress}], remote port: [${socket.remotePort}]`.yellow);
-                        socket.destroy();
-                        //socket.end();
-                    });
-                }
-                this.LogEx(`Closing httpServer.`);
-                await this.#httpServer.close();
-            }
-            
-            if (this.options.useDatabase) {
-                this.LogEx(`Ending database connections and pools.`);
-                await this.TerminateDatabase();
-                //await this.accessLayer.enddatabase();
-            }
-
-            if (this.options.clusterMode) {
-                this.LogEx(`Performing exit value: [${clusterPerformExit}]`);
-                if (clusterPerformExit) {
-                    this.LogEx(`Process will self terminate with process.exit(0).`);
-                } else {
-                    this.LogEx(`Child process will not self terminate. Terminate will be handled by master process.`);
-                }
-            }
-
-            //if (this.InstrumentController && this.InstrumentController.Workers.length > 0) {
-            if (this.InstrumentController) {
-                this.LogEx(`Ending publisher.`);
-                setTimeout(() => {
-                    //if (this.InstrumentController && this.InstrumentController.Workers.length > 0) {
-                    if (this.InstrumentController) {
-                        this.InstrumentController.InstrumentTerminate();
-                    }
-                }, 100);
-            }
-
-            //@@ always return here appears to always cleanly exit
-            // and cleanly exit from socket.io cluster adaptor
-            // without return here, socket.io cluster adaptor terminates in an error state
-            // as the implementation relies on cluster.on to send messages to worker threads
-            // but these have already been closed from the process.exit(0) below.
-
-            await Sleep(1000); // Allow socket.io time to clean-up
-
-            if (this.options.clusterMode) {
-                if (clusterPerformExit) {
-                    setTimeout(() => {
-                        process.exit(0);
-                    }, 0);
-                } 
-            } else {
-                if (this.options.processExitOnTerminate && this.options.processExitOnTerminate === true) {
-                    setTimeout(() => {
-                        this.LogEx(`Performing process.exit(0).`);
-                        process.exit(0);
-                    }, this.#masterProcessExitTime); // Give the workers time to terminate gracefully
-                } else {
-                    this.LogEx(`Performing process.exit(0) - Immediate.`);
-                }
-            }
-        } else {
-            this.LogEx(`Process already terminating.`);
-        }
-    }
-
-    SetupSTSServer = async(): Promise<void> => {
-        switch (this.options.serverType) {
-        case STSServerType.EXPRESS :
-            await this.#SetupExpressServer(false);
-            break;
-        case STSServerType.EXPRESS_TLS :
-            await this.#SetupExpressServer(true);
-            break;
-        case STSServerType.TCPRAW_TLS :
-            await this.#SetupTCPRawServer();
-            break;
-        case STSServerType.JSONRPC2_TLS :
-            await this.#SetupJSONRPCServer();
-            break;
-        }
-    }
-}

package/src_working2/singleprocessbase.ts

@@ -1,123 +0,0 @@
-/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
-import { $Options } from '@nsshunt/stsconfig'
-const goptions = $Options()
-
-import chalk from 'chalk';
-
-import { Gauge, GaugeTypes, InstrumentGaugeOptions, InstrumentGaugeTelemetry } from '@nsshunt/stsinstrumentation'
-
-import { ProcessOptions } from './processoptions'
-import { ISingleProcessBase } from './commonTypes';
-import { InstrumentDefinitions } from '@nsshunt/stspublisherserver'
-import { STSExpressServer } from './server'
-import { ServerProcessBase } from './serverprocessbase'
-
-import si from 'systeminformation' // https://systeminformation.io/
-
-export type EventCb = (socket: any, data: any) => void
-
-export class SingleProcessBase extends ServerProcessBase implements ISingleProcessBase
-{
-    /**
-	 * 
-	 * @param {SingleProcessBaseOptions} options 
-	 */
-    constructor(options: ProcessOptions) {
-        super(options)
-    }
-
-    override CollectAdditionalTelemetry(): void {
-        const siValueObject = {
-            currentLoad: 'currentLoad'
-        }
-        si.get(siValueObject).then(data => {
-            this.UpdateInstrument(Gauge.CPU_SYSTEM_LOAD_GAUGE, {
-                val: data.currentLoad.currentLoad
-            } as InstrumentGaugeTelemetry);
-        });
-    }
-
-    override GetAdditionalInstruments(): InstrumentDefinitions {
-        return [
-            [ Gauge.CPU_SYSTEM_LOAD_GAUGE, GaugeTypes.INSTRUMENT_GAUGE, {
-                interval: goptions.instrumentationObservationInterval, 
-                sampleSize: goptions.instrumentationTimeWindow
-            } as InstrumentGaugeOptions]
-        ]
-    }
-
-    /**
-	 * UIController (instance of UIController) to manage a console based user interface associated for this node application.
-	 * @returns UIController instance to manage a console based user interface associated for this node application. Null for no capability.
-	 */
-    override GetUIController(): any {
-        return null;
-    }
-
-    ProcessStarted() {
-        return null;
-    }
-
-    SetupServer(): Promise<boolean>
-    {
-        return new Promise((resolve, reject) => {
-            try {
-                this.SetupInstrumentation();
-                setTimeout(async () => {
-                    try {
-                        await this.SetupServerEx();
-                        resolve(true);
-                    } catch (error) {
-                        reject(error);
-                    }
-                }, 100);
-            } catch (error) {
-                reject(error);
-            }
-        })
-    }
-
-    SetupServerEx = async () => {
-        this.ProcessStartup();
-
-        if (this.options.expressServerRouteFactory || this.options.expressServerRouteStaticFactory) {
-            this.expressServer = new STSExpressServer(this.options, this);
-        }
-
-        this.LogEx(`Service instance starting. Instance Id: [${this.options.serviceInstanceId}]`);
-        this.LogEx(`Master process:${process.pid} started`);
-
-        this.LogSystemTelemetry();
-
-        process.on('SIGINT', async () => {
-            await this.Terminate(false, 'SIGINT');
-        });
-
-        process.on('SIGTERM', async () => {
-            await this.Terminate(false, 'SIGTERM');
-        });
-
-        process.on('exit', (code) => {
-            if (code === 0) {
-                this.LogEx(chalk.green(`Main Process: ${process.pid} terminated gracefully with code: ${code}`));
-            } else {
-                this.LogEx(chalk.red(`Main Process: ${process.pid} terminated with code: ${code}`));
-            }
-        });
-
-        await this.SetupSTSServer();
-
-        this.ProcessStarted();
-
-        this.LogEx(chalk.green(`Main process:${process.pid} started`));
-    }
-
-    async TerminateApplication()
-    {
-        await this.Terminate(false, 'SIGINT');
-    }
-
-    override ProcessTerminating = async (): Promise<void> => {
-        return;
-    }
-}

package/src_working2/socketIoServerHelper.ts

@@ -1,177 +0,0 @@
-/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
-import Debug from "debug";
-const debug = Debug(`proc:${process.pid}:socketiohelper`);
-
-import { JSONObject } from '@nsshunt/stsutils'
-
-import { Server, Namespace, Socket } from "socket.io";
-
-import { STSSocketIONamespace, STSServerSocket, STSNamespace, 
-    ISocketIoServerHelper, ServerEventCb, InterServerEvents } from './commonTypes'
-
-import { STSDefaultClientToServerEvents, STSDefaultServerToClientEvents } from '@nsshunt/stssocketio-client'
-
-export interface ISocketIoServerHelperOptions
-{
-    logger: (message: string) => void;
-}
-
-export class SocketIoServerHelper<ClientToServerEvents extends STSDefaultClientToServerEvents, ServerToClientEvents extends STSDefaultServerToClientEvents> implements ISocketIoServerHelper<ClientToServerEvents, ServerToClientEvents>
-{
-    #socketIoServerHelperOptions: ISocketIoServerHelperOptions
-
-    constructor(options: ISocketIoServerHelperOptions) { // IProcessBase
-        this.#socketIoServerHelperOptions = options;
-    }
-
-    #namespace: Record<string, STSSocketIONamespace> = { };
-
-    LogMessage = (namespace: STSSocketIONamespace, message: string): void => {
-
-        this.#socketIoServerHelperOptions.logger(`${namespace.namespace}: ${message}`);
-        /*
-        this.#stsApp.UpdateInstrument(Gauge.LOGGER, {
-            LogMessage: message
-        } as InstrumentLogTelemetry);
-        */
-    };
-
-    LeaveRoom = (namespace: STSSocketIONamespace, socket: Socket<ClientToServerEvents, ServerToClientEvents>, room: string): void => {
-        const logMessage = `${namespace.socketionamespace.name}: Leaving room [${room}]`;
-        debug(logMessage);
-        this.LogMessage(namespace, logMessage);
-        socket.leave(room);
-    };
-
-    JoinRoom = (namespace: STSSocketIONamespace, socket: Socket<ClientToServerEvents, ServerToClientEvents>, room: string): void => {
-        const logMessage = `${namespace.socketionamespace.name}: Socket joining room [${room}], ID: [${socket.id}]`;
-        debug(logMessage);
-        this.LogMessage(namespace, logMessage);
-        socket.join(room);
-    };
-
-    #SetupStandardEvents = (namespace: STSSocketIONamespace, socket: Socket<STSDefaultClientToServerEvents, STSDefaultServerToClientEvents>): void => {
-        socket.on("__STSdisconnect", (reason) => {
-            debug(`${namespace.socketionamespace.name}: socket disconnect, ID: [${socket.id}] [${reason}]`);
-        });
-
-        socket.on("__STSdisconnecting", (reason, callBackResult) => {
-            debug(`${namespace.socketionamespace.name}: socket disconnecting, ID: [${socket.id}] [${reason}]`);
-            callBackResult("__STSdisconnecting accepted by server.");
-        });
-
-        socket.on('__STSjoinRoom', (rooms: string[]): void => { //@@ names
-            rooms.forEach((room) => {
-                const logMessage = `${namespace.socketionamespace.name}:socket.on:joinRoom: Socket joining room [${room}], ID: [${socket.id}]`;
-                debug(logMessage);
-                this.JoinRoom(namespace, socket, room)
-            });
-        });
-
-        socket.on('__STSleaveRoom', (rooms: string[]): void => { //@@ names
-            rooms.forEach((room) => {
-                const logMessage = `${namespace.socketionamespace.name}:socket.on:joinRoom: Socket leaving room [${room}], ID: [${socket.id}]`;
-                debug(logMessage);
-                this.LeaveRoom(namespace, socket, room);
-            });
-        });
-
-        socket.on('__STSsendToRoom', (rooms: string[], payload: { command: string, payload: JSONObject }): void => {
-            rooms.forEach((room) => {
-                const logMessage = `${namespace.socketionamespace.name}:socket.on:sendToRoom: Sending to room [${room}], ID: [${socket.id}]`;
-                debug(logMessage);
-                // eslint-disable-next-line  @typescript-eslint/no-explicit-any
-                namespace.socketionamespace.to(room).emit(payload.command as any, payload);
-            });
-        });
-    }
-
-    // Use this middleward to check every incomming connection
-    #SetupConnectionMiddleware = (nameSpace: STSSocketIONamespace) => {
-        nameSpace.socketionamespace.use((socket, next) => {
-            //console.log(JSON.stringify(socket));
-            //console.log(JSON.stringify(socket.handshake.auth));
-            //console.log(JSON.stringify(socket.handshake.headers));
-            //if (isValid(socket.request)) {
-            const a=5; // for lint purposes
-            if (a === 5) {
-                next();
-            } else {
-                next(new Error("invalid"));
-            }
-        });
-    }
-
-    // Use this middleware to check very packet being received
-    #SetupMessageMiddleware = (socket: STSServerSocket) => {
-        socket.use(([event, ...args], next) => {
-            //console.log(JSON.stringify(event));
-            //console.log(JSON.stringify(args));
-            /*
-            if (isUnauthorized(event)) {
-                return next(new Error("unauthorized event"));
-            }
-            */
-            next();
-        });
-    }
-    
-    SetupNamespace = (io: Server, namespace: STSNamespace, rooms: string[], autoJoinRooms: boolean, /* serverSocketEvents: ServerSocketEvent[], */
-        socketConnectCallBack: ((socket: Socket<ClientToServerEvents, ServerToClientEvents, InterServerEvents>) => void) | null,
-        socketEventsCallBack: ((socket: Socket<ClientToServerEvents, ServerToClientEvents, InterServerEvents>) => void) | null
-    ): Namespace<ClientToServerEvents, ServerToClientEvents, InterServerEvents> => {
-        // Create STS Command Centre Client namespace
-        this.#namespace[namespace] = {
-            namespace: namespace,
-            pid: process.pid,
-            socketionamespace: io.of(`/${namespace}/`)
-        }
-
-        this.#SetupConnectionMiddleware(this.#namespace[namespace]);
-
-        this.#namespace[namespace].socketionamespace.on("connection", socket => {
-            const logMessage = `${namespace}: Socket connected, ID: [${socket.id}]`;
-            debug(logMessage);
-            this.LogMessage(this.#namespace[namespace], logMessage);
-            debug(`${namespace}: Auth: [${JSON.stringify(socket.handshake.auth)}]`);
-
-            this.#SetupMessageMiddleware(socket);
-
-            if (autoJoinRooms) {
-                rooms.map((room) => {
-                    this.JoinRoom(this.#namespace[namespace], socket, room);
-                });
-            }
-
-            this.#SetupStandardEvents(this.#namespace[namespace], socket);
-
-            if (socketConnectCallBack) {
-                setTimeout(() => {
-                    socketConnectCallBack(socket);
-                }, 0);
-            }
-
-            if (socketEventsCallBack) {
-                socketEventsCallBack(socket);
-            }
-        });
-
-        return this.#namespace[namespace].socketionamespace as Namespace<ClientToServerEvents, ServerToClientEvents, InterServerEvents>;
-    }
-
-    GetSTSSocketIONamespace = (namespace: string): STSSocketIONamespace => {
-        return this.#namespace[namespace];
-    }
-
-    DisconnectSockets = (): void =>
-    {
-        for (const [, namespace] of Object.entries(this.#namespace)) {
-            namespace.socketionamespace.disconnectSockets();
-        }
-        this.#namespace = { };
-    }
-
-    SetupEvent(event: ClientToServerEvents, eventCb: ServerEventCb): ISocketIoServerHelper<ClientToServerEvents, ServerToClientEvents> {
-        return this as any;
-    }
-}