@nsshunt/stsappframework 3.0.187 → 3.1.2

package/src/publishertransports/publishTransportDirect.ts

@@ -1,6 +1,7 @@
 /* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
 
 //import Debug from "debug";
+//const debug = Debug(`proc:${process.pid}:PublishRESTServer`);
 
 import { IPublisherTransport, IInstrumentPayload } from '@nsshunt/stspublisherserver'
 import { IMKafkaManager } from './../kafka/IMKafkaManager'

package/src/server.ts

@@ -29,7 +29,8 @@ export class STSExpressServer
 
         const serverNetworkMiddleware = new ServerNetworkMiddleware({ 
             name: (stsApp.options as ProcessOptions).serviceName,
-            outputDebug: false
+            outputDebug: false,
+            logger: stsApp.options?.logger
         });
 
         serverNetworkMiddleware.on(ServerNetworkMiddlewareEventName.UpdateInstrument_SERVER_NET_VAL, (data: ISocketRecord) => {

package/src/singleprocessbase.ts

@@ -14,6 +14,8 @@ import { ServerProcessBase } from './serverprocessbase'
 
 import si from 'systeminformation' // https://systeminformation.io/
 
+import { STSTransportLoggerWinston } from './stsTransportLoggerWinston'
+
 export type EventCb = (socket: any, data: any) => void
 
 export class SingleProcessBase extends ServerProcessBase implements ISingleProcessBase
@@ -55,7 +57,12 @@ export class SingleProcessBase extends ServerProcessBase implements ISingleProce
     }
 
     ProcessStarted() {
-        return null;
+        const transport = new STSTransportLoggerWinston({
+            stsApp: this
+        });
+        setTimeout(() => {
+            (this.options.logger as any).add(transport);
+        }, 0);
     }
 
     SetupServer(): Promise<boolean>

package/src/socketIoServerHelper.ts

@@ -1,4 +1,7 @@
 /* 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, ISTSLogger } from '@nsshunt/stsutils'
 
 import { Server, Namespace, Socket } from "socket.io";
@@ -23,10 +26,6 @@ export class SocketIoServerHelper<ClientToServerEvents extends STSDefaultClientT
 
     #namespace: Record<string, STSSocketIONamespace> = { };
 
-    #LogDebugMessage(message: any) {
-        this.#socketIoServerHelperOptions.logger.debug(message);
-    }
-
     LogMessage = (namespace: STSSocketIONamespace, message: string): void => {
 
         this.#socketIoServerHelperOptions.logger.info(`${namespace.namespace}: ${message}`);
@@ -39,32 +38,32 @@ export class SocketIoServerHelper<ClientToServerEvents extends STSDefaultClientT
 
     LeaveRoom = (namespace: STSSocketIONamespace, socket: Socket<ClientToServerEvents, ServerToClientEvents>, room: string): void => {
         const logMessage = `${namespace.socketionamespace.name}: Leaving room [${room}]`;
-        this.#LogDebugMessage(logMessage);
+        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}]`;
-        this.#LogDebugMessage(logMessage);
+        debug(logMessage);
         this.LogMessage(namespace, logMessage);
         socket.join(room);
     };
 
     #SetupStandardEvents = (namespace: STSSocketIONamespace, socket: Socket<STSDefaultClientToServerEvents, STSDefaultServerToClientEvents>): void => {
         socket.on("__STSdisconnect", (reason) => {
-            this.#LogDebugMessage(`${namespace.socketionamespace.name}: socket disconnect, ID: [${socket.id}] [${reason}]`);
+            debug(`${namespace.socketionamespace.name}: socket disconnect, ID: [${socket.id}] [${reason}]`);
         });
 
         socket.on("__STSdisconnecting", (reason, callBackResult) => {
-            this.#LogDebugMessage(`${namespace.socketionamespace.name}: socket disconnecting, ID: [${socket.id}] [${reason}]`);
+            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}]`;
-                this.#LogDebugMessage(logMessage);
+                debug(logMessage);
                 this.JoinRoom(namespace, socket, room)
             });
         });
@@ -72,7 +71,7 @@ export class SocketIoServerHelper<ClientToServerEvents extends STSDefaultClientT
         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}]`;
-                this.#LogDebugMessage(logMessage);
+                debug(logMessage);
                 this.LeaveRoom(namespace, socket, room);
             });
         });
@@ -80,7 +79,7 @@ export class SocketIoServerHelper<ClientToServerEvents extends STSDefaultClientT
         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}]`;
-                this.#LogDebugMessage(logMessage);
+                debug(logMessage);
                 // eslint-disable-next-line  @typescript-eslint/no-explicit-any
                 namespace.socketionamespace.to(room).emit(payload.command as any, payload);
             });
@@ -132,9 +131,9 @@ export class SocketIoServerHelper<ClientToServerEvents extends STSDefaultClientT
 
         this.#namespace[namespace].socketionamespace.on("connection", socket => {
             const logMessage = `${namespace}: Socket connected, ID: [${socket.id}]`;
-            this.#LogDebugMessage(logMessage);
+            debug(logMessage);
             this.LogMessage(this.#namespace[namespace], logMessage);
-            this.#LogDebugMessage(`${namespace}: Authentication Handshake: [${JSON.stringify(socket.handshake.auth)}]`);
+            debug(`${namespace}: Authentication Handshake: [${JSON.stringify(socket.handshake.auth)}]`);
 
             this.#SetupMessageMiddleware(socket);
 

package/src/stsAppFrameworkTransportWinston.ts

@@ -0,0 +1,28 @@
+/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
+import Transport, { TransportStreamOptions } from 'winston-transport'
+
+import { IProcessBase } from './commonTypes'
+
+export interface ISTSAppFrameworkTransportWinstonOptions extends TransportStreamOptions {
+    stsContext: string
+    app: IProcessBase
+}
+
+export class STSAppFrameworkTransportWinston extends Transport {
+
+    #options: ISTSAppFrameworkTransportWinstonOptions;
+
+    constructor(opts: ISTSAppFrameworkTransportWinstonOptions) {
+        super(opts);
+        this.#options = opts;
+    }
+  
+    log(info: any, callback: any) {
+        //setImmediate(() => {
+        this.#options.app.LogEx(info.message);
+
+        this.emit('logged', info);
+        callback();
+        //});
+    }
+}

package/src/stsTransportLoggerWinston.ts

@@ -1,14 +1,15 @@
 /* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
 import Transport, { TransportStreamOptions } from 'winston-transport'
+
 import { IProcessBase } from './commonTypes'
 
-interface ISTSTransportLoggerWinstonOptions extends TransportStreamOptions {
-    //stsContext: string
+export interface ISTSTransportLoggerWinstonOptions extends TransportStreamOptions {
     stsApp: IProcessBase
 }
 
 export class STSTransportLoggerWinston extends Transport {
-    #options: ISTSTransportLoggerWinstonOptions
+
+    #options: ISTSTransportLoggerWinstonOptions;
 
     constructor(opts: ISTSTransportLoggerWinstonOptions) {
         super(opts);

package/src/{stsTransportDebuggerWinston.ts → stsTransportWinston.ts}

@@ -3,25 +3,25 @@ import Transport, { TransportStreamOptions } from 'winston-transport'
 
 import debugModule from 'debug'
 
-export interface ISTSTransportDebuggerWinstonOptions extends TransportStreamOptions {
+export interface ISTSTransportWinstonOptions extends TransportStreamOptions {
     stsContext: string
     debugger?: debugModule.Debugger
 }
 
 export function UpdateSTSTransportWithDebugger(logger: any, newDebugger: any): void {
     const stsTransport: Transport | undefined = logger.transports.find((transport: any) => {
-        return transport instanceof STSTransportDebuggerWinston
+        return transport instanceof STSTransportWinston
     });
     if (stsTransport) {
-        (stsTransport as STSTransportDebuggerWinston).debugger = newDebugger
+        (stsTransport as STSTransportWinston).debugger = newDebugger
     }
 }
 
-export class STSTransportDebuggerWinston extends Transport {
+export class STSTransportWinston extends Transport {
 
-    #options: ISTSTransportDebuggerWinstonOptions;
+    #options: ISTSTransportWinstonOptions;
 
-    constructor(opts: ISTSTransportDebuggerWinstonOptions) {
+    constructor(opts: ISTSTransportWinstonOptions) {
         super(opts);
         this.#options = opts;
     }

package/src/testing/appConfig.ts

@@ -85,7 +85,7 @@ export function ServiceConfigOptions(clusterMode: boolean, isMaster: boolean): P
             instrumentationTimeWindow: goptions.instrumentationTimeWindow,
 
             useRedisAdaptor: false,
-            workerExec: './dist/testing/app.js',
+            //workerExec: './dist/testing/app.js',
 
             logger: logger,
             publisherLogger: publisherLogger

package/src/vitesttesting/appConfig.ts

@@ -0,0 +1,110 @@
+import { v4 as uuidv4 } from 'uuid';
+import express from 'express';
+
+import { $Options } from '@nsshunt/stsconfig'
+const goptions = $Options()
+
+import { ProcessOptions, IProcessBase, STSServerType } from './..'
+
+import { STSExpressRouteFactory } from './server'
+
+import winston from 'winston'
+
+/*
+// nid: `${goptions.rest01servicename} @ ${goptions.rest01serviceversion}  |  ${this.options.globalServiceData.serviceInstanceId} @ ${os.hostname()}   ^   ${process.pid} @ ${(cluster.isMaster ? process.pid : process.ppid)}`,
+//                        <serviceId>                                                                 <serviceInstanceId>                                                       <serviceInstanceProcessId>
+//              <serviceName>                    <serviceVersion>                                  <sid>                              <hostName>               <pid>                                     <ppid>
+//                                                  << ............... Static Nid ............... >>                                                                    << ............... Dynamic Nid ............... >>
+// Note: The final nid will NOT contain the NID_SEPERATOR character. This will be replaced with the SEPERATOR character.
+const Context = (isMaster, serviceInstanceId) => {
+    return {
+        nid: `\
+${goptions.rest01servicename}${ModelDelimeter.COMPONENT_SEPERATOR}${goptions.rest01serviceversion}\
+${ModelDelimeter.SEPERATOR}\
+${serviceInstanceId}${ModelDelimeter.COMPONENT_SEPERATOR}${os.hostname()}\
+${ModelDelimeter.NID_SEPERATOR}\
+${process.pid}${ModelDelimeter.COMPONENT_SEPERATOR}${(isMaster ? process.pid : process.ppid)}`
+    }
+}
+*/
+
+export function ServiceConfigOptions(clusterMode: boolean, isMaster: boolean): ProcessOptions {
+    winston.format.combine(
+        winston.format.colorize(),
+        winston.format.simple()
+    );
+
+    const logger = winston.createLogger({
+        level: 'silly',
+        format: winston.format.combine(
+            winston.format.colorize(),
+            winston.format.simple()
+        ),
+        transports: [
+            new winston.transports.Console()
+        ]
+    });
+
+    const publisherLogger = winston.createLogger({
+        level: 'info',
+        format: winston.format.combine(
+            winston.format.colorize(),
+            winston.format.simple()
+        ),
+        transports: [
+            new winston.transports.Console()
+        ]
+    });
+
+    if (isMaster === true) {
+        const serviceInstanceId = uuidv4();
+        const data: ProcessOptions = {
+            serverType: STSServerType.EXPRESS_TLS,
+            clusterMode: clusterMode,
+            wssServer: true,
+            useLatency: true,
+            httpsServerKeyPath: goptions.httpsserverkeypath,
+            httpsServerCertificatePath: goptions.httpsservercertpath,
+            processExitOnTerminate: true,
+            serviceInstanceId: serviceInstanceId,
+            useDatabase: false,
+
+            isMaster: isMaster,
+            endpoint: goptions.rest01endpoint,
+            apiRoot: goptions.rest01apiroot,
+            listenPort: goptions.rest01hostport,
+            port: goptions.rest01port,
+            prometheusSupport: goptions.rest01prometheussupport,
+            prometheusClusterPort: goptions.rest01prometheusclusterport,
+            serviceName: goptions.rest01servicename,
+            serviceVersion: goptions.rest01serviceversion,
+            consoleLogging: true,
+            instrumentLogging: true,
+
+            instrumentationObservationInterval: goptions.instrumentationObservationInterval,
+            instrumentationTimeWindow: goptions.instrumentationTimeWindow,
+
+            useRedisAdaptor: false,
+            //workerExec: './dist/testing/app.js',
+
+            logger: logger,
+            publisherLogger: publisherLogger
+        }
+
+        if (!clusterMode) {
+            data.expressServerRouteFactory = (app: express.Express, stsApp: IProcessBase) => {
+                return new STSExpressRouteFactory(app, stsApp);
+            }
+        }
+    
+        return data;
+    } else {
+        const data: ProcessOptions = JSON.parse(process.env['STS_GSD_SII'] as string) as ProcessOptions;
+        data.expressServerRouteFactory = (app: express.Express, stsApp: IProcessBase) => {
+            return new STSExpressRouteFactory(app, stsApp);
+        }
+        data.logger = logger;
+        data.publisherLogger = publisherLogger;
+        return data;
+    }
+}

package/src/vitesttesting/appSingleWSS.ts

@@ -0,0 +1,82 @@
+/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
+import chalk from 'chalk';
+
+import { SingleProcessBase, STSNamespace, STSRoom, SocketIoServerHelper, STSSocketIONamespace, ProcessOptions } from './../index'
+
+import { Socket } from "socket.io";
+
+import { InterServerEvents } from './../commonTypes'
+
+import { ClientToServerEvents, ServerToClientEvents } from './wsevents'
+
+export class AppSingleWSS extends SingleProcessBase
+{
+    constructor(options: ProcessOptions)
+    {
+        super(options);
+        this.socketIoServerHelper = new SocketIoServerHelper<ClientToServerEvents, ServerToClientEvents>({
+            logger: this.options.logger
+        });
+    }
+
+    #LogErrorMessage(message: any) {
+        this.options.logger.error(message);
+    }
+
+    #LogInfoMessage(message: any) {
+        this.options.logger.info(message);
+    }
+
+    override ProcessStarted() {
+        super.ProcessStarted();
+        
+        if (this.socketIoServerHelper) {
+            this.socketIoServerHelper.SetupNamespace(this.io as any, STSNamespace.STSMonitor, 
+                // Auto joinn room list
+                [ 
+                    STSRoom.STSInstrumentDataRoom,
+                    STSRoom.STSRunnerRoom,
+                    'room3'
+                ], 
+                true, // Make any connecting client automatically join the room list above
+
+                // Connect call back when a client connects
+                (socket: Socket<ClientToServerEvents, ServerToClientEvents, InterServerEvents>) => {
+                    this.#LogInfoMessage(chalk.gray(`WorkerProcess.#SendIPCMessageToMaster: Id: [${socket.id}] eventName: [connect]`));
+                },
+
+                // Custom client to server events
+                (socket: Socket<ClientToServerEvents, ServerToClientEvents, InterServerEvents>) => {
+                    socket.on('subscribe', (data: any) => {
+                        socket.emit('subscribeAck', data);
+                    });
+                    socket.on('unsubscribe', (data: any) => {
+                        socket.emit('unsubscribeAck', data);
+                    });
+                    socket.on('subscribeKeepAlive', (data: any) => {
+                        socket.emit('subscribeKeepAliveAck', data);
+                    });
+                    socket.on('done', () => {
+                        socket.emit('doneAck');
+                    });
+                    socket.on('compute', (arg: number, cb) => {
+                        const res = arg * 2;
+                        cb(res.toString());
+                    });
+                    socket.on('compute2', (arg, cb) => {
+                        cb({data: arg*2});
+                    });
+                })
+        } else {
+            throw new Error('WorkerProcess:WorkerStarted(): this.socketIoHelper is null')
+        }
+        return null;
+    }
+
+    get stsMonitorNamespace(): STSSocketIONamespace | null {
+        if (this.socketIoServerHelper !== null) {
+            return this.socketIoServerHelper.GetSTSSocketIONamespace(STSNamespace.STSMonitor);
+        }
+        return null;
+    }
+}

package/src/vitesttesting/server.ts

@@ -0,0 +1,18 @@
+import express from 'express';
+
+import { STSLatencyRoute, IProcessBase } from './..'
+
+import { $Options } from '@nsshunt/stsconfig'
+const goptions = $Options()
+
+export class STSExpressRouteFactory
+{
+    constructor(app: express.Express, stsApp: IProcessBase)
+    {
+        const stslatency = new STSLatencyRoute(stsApp);
+
+        // Note: This MUST come first as the latency end point is on the same path as the reosurce path.
+        // If stsresourceRouter came first, it would think that /latency was a resource name.
+        app.use(`${goptions.rest01apiroot}`, stslatency.router);
+    }
+}

package/src/{testing → vitesttesting}/singleservertest.test.ts

@@ -7,7 +7,9 @@ import chalk from 'chalk';
 import axios, { AxiosError, AxiosResponse } from 'axios';
 
 import { Sleep } from '@nsshunt/stsutils'
-import { SingleProcessBase, MasterProcessBase } from './..'
+//import { SingleProcessBase, MasterProcessBase } from './..'
+
+import { AppSingleWSS } from './appSingleWSS'
 
 import { ServiceConfigOptions } from './appConfig'
 
@@ -22,27 +24,12 @@ import { SocketIoClientHelper, ISocketIoClientHelperOptions } from '@nsshunt/sts
 
 import { STSNamespace } from './../index'
 
-//const { Kafka } = require('kafkajs')
-
-//import { DockerComposeEnvironment, Wait, AlwaysPullPolicy } from 'testcontainers'
-
 import { ServerToClientEvents, ClientToServerEvents } from './wsevents'
 import { Socket } from 'socket.io-client'
-//import { TimeSeriesBucketTimestamp } from 'redis';
 
 describe("Single Server Test", () =>
 {
-    /*
-    const kafka = new Kafka({
-        clientId: 'my-app',
-        brokers: ['192.168.14.92:9092']
-        //brokers: ['localhost:9092', 'kafka2:9092'],
-    })
-    let producer: any;
-    let environment: any;
-    */
-    
-    let app: SingleProcessBase | MasterProcessBase | null = null;
+    let app: AppSingleWSS | null = null;
     let httpsAgent: https.Agent | null = null;
 
     const endpoint = 'https://localhost'
@@ -58,8 +45,6 @@ describe("Single Server Test", () =>
         }
     }
 
-    // Use ServerToClientEvents<true> when the client will pass a request to server with a call back expected with a timeout
-    //@@const socketUtils = new SocketIoClientHelper<ServerToClientEvents<true>, ClientToServerEvents>(socketUtilsoptions);
     const socketUtils = new SocketIoClientHelper<ServerToClientEvents, ClientToServerEvents>(socketUtilsoptions);
 
     const instrumentManagerAddress = 
@@ -122,92 +107,11 @@ describe("Single Server Test", () =>
         }
     }
 
-    /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars */
-    /*
-    const socketDetail: ISocketDetail = socketUtils.SetupClientSideSocket('STSUITerm', instrumentManagerAddress, [
-        {
-            eventName: 'hello',
-            eventCb: (socket: any, data: any): void =>  {
-                debug(`Received: [hello:${data}]`);
-            }
-        },
-        {
-            eventName: 'goodbye',
-            eventCb: (socket: any, data: any) => {
-                debug(`Received: [goodbye:${data}]`);
-            }
-        },
-        {
-            eventName: 'registerEcho',
-            eventCb: (socket: any, data: any) => {
-                debug(`Received: [registerEcho:${JSON.stringify(data)}]`);
-            }
-        },
-        {
-            eventName: STSEvent.connect,
-            eventCb: (socket: STSClientSocket, data: any) => {
-                socket.emit('joinRoom', STSRoom.STSInstrumentDataRoom);
-            }
-        },
-        {
-            eventName: 'sts_connect_reply',
-            eventCb: (socket: STSClientSocket, data: any) => {
-                debug(`Received: [sts_connect_reply:${JSON.stringify(data)}]`);
-            }
-        }
-    ]);
-    */
-
     beforeAll(async () => 
     {
-        /*
-        const composeFilePath = "/home/marcusbettens/projects/stsappframework/src/testing";
-        const composeFile = "docker-compose.yml";
-        try {
-            environment = await new DockerComposeEnvironment(composeFilePath, composeFile)
-                .withWaitStrategy("kafka", Wait.forLogMessage("[KafkaServer id=1001] started (kafka.server.KafkaServer)"))
-                .withPullPolicy(new AlwaysPullPolicy())
-                .up()
-        } catch (error) {
-            this.#LogErrorMessage(error)
-            throw error;
-        }
-
-        */
-
-        /*
-        producer = kafka.producer()
-        await producer.connect()
-        */
-
-        /*
-        process.env.AS_ENDPOINT = testHelper.authHost;
-        process.env.AS_HOST_PORT = testHelper.authPort;
-        process.env.AS_PORT = testHelper.authPort;
-
-        $ResetOptions();
-        //goptions = $Options()
-
-        //goptions.asendpoint = testHelper.authHost;
-        //goptions.asport = testHelper.authPort;
-        */
-
-        const clusterMode = true;
-
-        if (clusterMode) {
-            const appOptions = ServiceConfigOptions(clusterMode, true);
-            appOptions.processExitOnTerminate = false;
-            app = new MasterProcessBase(appOptions)
-        } else {
-            const appOptions = ServiceConfigOptions(clusterMode, true);
-            appOptions.processExitOnTerminate = false;
-            app = new SingleProcessBase(appOptions)
-        }
-
-        const appOptions = ServiceConfigOptions(true, true);
+        const appOptions = ServiceConfigOptions(false, true);
         appOptions.processExitOnTerminate = false;
-        //app = new SingleProcessBase(appOptions)
-        app = new MasterProcessBase(appOptions)
+        app = new AppSingleWSS(appOptions)
         await app.SetupServer();
         await Sleep(3000);
     }, 60000);
@@ -216,23 +120,8 @@ describe("Single Server Test", () =>
     {
         await Sleep(500);
 
-        // Kafka disconnect
-        //await producer.disconnect()
-
-        //@@await environment.down();
-
-        //await (app as SingleProcessBase).TerminateApplication();
         await Sleep(1000);
         app = null;
-
-        /*
-
-        await testHelper.StopAuthService();
-        await testHelper.StopDatabase();
-        await testHelper.StopNetwork();
-
-        await Sleep(2000);
-        */
     }, 15000);
 
     test('Testing Module', async () => 
@@ -245,16 +134,6 @@ describe("Single Server Test", () =>
         const num = 50;
         expect.assertions(num * 2);
         for (let i=0; i < num; i++) {
-
-            /*
-            const retValKafka = await producer.send({
-                topic: 'topic-name2',
-                messages: [
-                    { key: 'key1', value: `hello world - ${i}` },
-                ],
-            })
-            */
-
             const retVal = await getLatency();
             const retValObj = retVal?.data.data;
             expect(retValObj).toMatch('Ping Completed At:');
@@ -272,6 +151,7 @@ describe("Single Server Test", () =>
             // The address defines the namespace to connect to (i.e. io.of('/address'))
             instrumentManagerAddress,
             // Connected call back
+            // eslint-disable-next-line  @typescript-eslint/no-unused-vars
             (socket: Socket<ServerToClientEvents, ClientToServerEvents>) => {
                 debug(chalk.green(`connected - 1`));
                 expect(1).toEqual(1);
@@ -330,7 +210,6 @@ describe("Single Server Test", () =>
             }
         });
 
-
         while (!complete) {
             await Sleep(100);
         }

package/src/vitesttesting/wsevents.ts

@@ -0,0 +1,33 @@
+/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
+import { STSDefaultServerToClientEvents, STSDefaultClientToServerEvents } from '@nsshunt/stssocketio-client'
+
+// Syntax sugar from socket.io
+// https://socket.io/docs/v4/typescript/#emitting-with-a-timeout
+//type WithTimeoutAck<isSender extends boolean, args extends any[]> = isSender extends true ? [Error, ...args] : args;
+
+//export interface ServerToClientEvents<isSender extends boolean = false> extends STSServerToClientEvents {
+export interface ServerToClientEvents extends STSDefaultServerToClientEvents {
+        /*
+    noArg: () => void;
+    basicEmit: (a: number, b: string, c: Buffer) => void;
+    withAck: (d: string, callback: (e: number) => void) => void;
+    */
+
+    subscribeAck: (data: any) => void;
+    unsubscribeAck: (data: any) => void;
+    subscribeKeepAliveAck: (data: any) => void;
+    doneAck: () => void;
+}
+  
+//export interface ClientToServerEvents<isSender extends boolean = false> extends STSClientToServerEvents {
+export interface ClientToServerEvents extends STSDefaultClientToServerEvents {
+    subscribe: (data: any) => void;
+    unsubscribe: (data: any) => void;
+    subscribeKeepAlive: (data: any) => void;
+    done: () => void;
+
+    //compute: (arg: number, callback: (...args: WithTimeoutAck<isSender, [string]>) => void) => void;
+    //compute2: (arg: number, callback: (...args: WithTimeoutAck<isSender, [{ data: any}]>) => void) => void;
+    compute: (arg: number, callback: (data: string) => void) => void;
+    compute2: (arg: number, callback: (data: { data: any}) => void) => void;
+}