@nsshunt/stsappframework 3.0.94 → 3.0.95

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nsshunt/stsappframework",
-  "version": "3.0.94",
+  "version": "3.0.95",
   "description": "",
   "main": "dist/index.js",
   "types": "./types/index.d.ts",

package/src_new/authDefs.ts

@@ -0,0 +1,37 @@
+export enum Permission {
+	STS_GLOBAL_ADMIN_PERMISSION = "STSGlobalAdminPermission",
+
+	STSREST01_CREATE_PERMISSION = "STSREST01CreatePermission",
+	STSREST01_READ_PERMISSION = "STSREST01ReadPermission",
+	STSREST01_UPDATE_PERMISSION = "STSREST01UpdatePermission",
+	STSREST01_DELETE_PERMISSION = "STSREST01DeletePermission",
+
+	STSAUTH_LOGIN_PERMISSION = "STSAuthLoginPermission",
+	STSAUTH_CREATE_PERMISSION = "STSAuthCreatePermission",
+	STSAUTH_READ_PERMISSION = "STSAuthReadPermission",
+	STSAUTH_UPDATE_PERMISSION = "STSAuthUpdatePermission",
+	STSAUTH_DELETE_PERMISSION = "STSAuthDeletePermission",
+
+	STSUITERMINAL_EXECUTE = "STSUITerminalExecute",
+
+	STSCLI_EXECUTE = "STSCLIExecute",
+
+	STSUIWEBAPP_EXECUTE = "STSUIWebAppExecute",
+
+	STSUSERAGENTRUNNER_EXECUTE = "STSUserAgentRunnerExecute",
+
+	STSINSTRUMENTMANAGER_CREATE_PERMISSION = "STSInstrumentManagerCreatePermission",
+	STSINSTRUMENTMANAGER_READ_PERMISSION = "STSInstrumentManagerReadPermission",
+	STSINSTRUMENTMANAGER_UPDATE_PERMISSION = "STSInstrumentManagerUpdatePermission",
+	STSINSTRUMENTMANAGER_DELETE_PERMISSION = "STSInstrumentManagerDeletePermission",
+
+	STSTESTORCHESTRATOR_CREATE_PERMISSION = "STSTestOrchestratorCreatePermission",
+	STSTESTORCHESTRATOR_READ_PERMISSION = "STSTestOrchestratorReadPermission",
+	STSTESTORCHESTRATOR_UPDATE_PERMISSION = "STSTestOrchestratorUpdatePermission",
+	STSTESTORCHESTRATOR_DELETE_PERMISSION = "STSTestOrchestratorDeletePermission",
+
+	STSTESTRUNNER_CREATE_PERMISSION = "STSTestRunnerCreatePermission",
+	STSTESTRUNNER_READ_PERMISSION = "STSTestRunnerReadPermission",
+	STSTESTRUNNER_UPDATE_PERMISSION = "STSTestRunnerUpdatePermission",
+	STSTESTRUNNER_DELETE_PERMISSION = "STSTestRunnerDeletePermission"
+}

package/src_new/authutilsnode.ts

@@ -0,0 +1,375 @@
+import tough from 'tough-cookie';
+import https from 'https'
+import jwt from 'jsonwebtoken';
+import { jwtDecode } from "jwt-decode";
+import jwksClient from 'jwks-rsa';
+
+import axios from 'axios';
+
+import { $Options } from '@nsshunt/stsconfig'
+const goptions = $Options()
+
+import debugModule from 'debug'
+
+import { GetErrorPayload, JSONObject } from '@nsshunt/stsutils'
+
+import { AppFrameworkErrorCode } from './validation/errors'
+
+import { StatusCodes } from 'http-status-codes';
+
+import chalk from 'chalk';
+
+export interface IAuthUtilsNodeOptions {
+    permissions: string[]
+}
+
+/*
+export enum STSClientID {
+    STSRest01Service = 'KgSyRECcvnJwwOZqf7GPqUw508sx7VBFEbDC0iP4oeY=',
+    STSAuthService = 'q6a9F0kksXDDcrsCUKRwHKDnTNh7yZfxCShAgIJqfGg=',
+    STSUITerminal = 'U0E4c4cuRKlBsGo7OhOl3qTkoNGFBXjORUS/T4R4xyA=',
+    STSCLI = 'EcCpnQOIQFizAnWphlFJ4tSylosgVnwKTSNtgwuL2tw=',
+    STSUIWebApp = 'lww8Je8n2P0OI/KEfJ+4p/bqsk8uE/noeq13tl4zlQ0=',
+    XXSTSUserAgentRunnerX = 'y1h2nNr1BzTVPIzNmP/f041uxbnyZYTJeF/5GcwRCtw=',
+    STSInstrumentManagerService = 'l8u2E912eR44ZYRHUkSBCCnDOXxQqYOPahDVQzYowrw=',
+    STSTestOrchestratorService = 'CU1sVlS6vsEe3O3VvNzKFdBnQd9pQ83w9RyVx/7tJfc=',
+    STSTestRunnerNode = 'aX9dJbsT06V1G4j06xEIQ/rZ2CDlpzggU58aLtZ8fzE=',
+    STSBrokerService = 'TRppBuvxcjL7jrY9lCASJ5st8JpU8WlhAUAWoX/KKQ4=',
+    STSTestingService = '4Mtb3ABdSzZvSz4T51HPJhT14znVnqVDRFiZsvDNAOg=',
+    XXSTSAuthenticateSPAXX = 'v4qBrds3Autl/i86xT+5z0K53kJ/2hHTfxNo0QO/0Jk=',
+    STSTestRunnerAgentSPA = 'yDbklCH3awzDNuHICuco9mjDqhdzCa8m7w/UE9Opexc=',
+    STSClientApp01SPA = 'FDX/CPyDb3m6d9G2k+wDX8Uvey+yCkllaT4EuEt4QyU=',
+    PowerPlatformCustomConnectorSPA = 'fcdcebb5-d154-4699-b99d-87d29e5e148f'
+}
+*/
+
+export class AuthUtilsNode
+{
+    #cookiejar: tough.CookieJar;
+    #httpsAgent: https.Agent | null = null;
+    #debug = debugModule(`proc:${process.pid}:AuthUtilsNode`);
+    // Regular expression to match the origin
+    #originRegex = /^(api:\/\/\w+)/;
+
+    constructor() {
+        this.#cookiejar = new tough.CookieJar();
+    }
+
+    #GetHttpsAgent = () =>
+    {
+        if (this.#httpsAgent === null) {
+            // https://nodejs.org/api/http.html#class-httpagent
+            this.#httpsAgent = new https.Agent({ 
+                keepAlive: goptions.keepAlive,
+                maxSockets: goptions.maxSockets,
+                maxTotalSockets: goptions.maxTotalSockets,
+                maxFreeSockets: goptions.maxFreeSockets,
+                timeout: goptions.timeout,
+                rejectUnauthorized: false
+            });
+        }
+        return this.#httpsAgent;
+    }
+
+    VerifyRequestMiddlewareFactory(options: IAuthUtilsNodeOptions) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return async function(req: any, res: any, next: any) {
+            if (options.permissions) {
+                const scopes = req.auth.scope.split(' ');
+                const requiredPermissions = [ ];
+                for (let i=0; i < options.permissions.length; i++) {
+                    const permission = options.permissions[i];
+                    if (!scopes.includes(permission)) {
+                        requiredPermissions.push(permission);
+                    }
+                }
+                if (requiredPermissions.length > 0) {
+                    const errorPayload = GetErrorPayload(AppFrameworkErrorCode.APPFRAMEWORK_MISSING_PERMISSION, requiredPermissions);
+                    res.status(StatusCodes.UNAUTHORIZED).send( { status: StatusCodes.UNAUTHORIZED, error: errorPayload });
+                    return;
+                }
+            }
+            next();
+        }
+    }
+    /*
+	let cookies = await this.GetCookiesFromJar();
+	const valid = this.#ValidateCookies(cookies);
+	if (valid) {
+		next();
+	} else {
+		const error = { }; //@@
+		const invalidToken = false; //@@
+		if (invalidToken)
+		{
+			res.status(StatusCodes.UNAUTHORIZED).send( { status: StatusCodes.UNAUTHORIZED, error: 'Invalid Token', detail: error } );
+		} else{
+			res.status(StatusCodes.INTERNAL_SERVER_ERROR).send( { status: StatusCodes.INTERNAL_SERVER_ERROR, error: 'Operation was not successful', detail: error } );
+		}
+	}
+	*/
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async verifyRequestMiddleware(req: any, res: any, next: any)
+    {
+        next();
+        /*
+		
+		let cookies = await this.GetCookiesFromJar();
+
+		const valid = this.#ValidateCookies(cookies);
+
+		if (valid) {
+			next();
+		} else {
+			const error = { }; //@@
+			const invalidToken = false; //@@
+			if (invalidToken)
+			{
+				res.status(StatusCodes.UNAUTHORIZED).send( { status: StatusCodes.UNAUTHORIZED, error: 'Invalid Token', detail: error } );
+			} else{
+				res.status(StatusCodes.INTERNAL_SERVER_ERROR).send( { status: StatusCodes.INTERNAL_SERVER_ERROR, error: 'Operation was not successful', detail: error } );
+			}
+		}
+		*/
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    SetCookiesToJar = async (headers: Record<string, any>, endpoint: string): Promise<tough.Cookie[]> =>
+    {
+        if (headers['set-cookie']) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            headers['set-cookie'].map((headerCookie: any) => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const cookie: any = tough.Cookie.parse(headerCookie);
+                this.#cookiejar.setCookieSync(cookie, endpoint);
+            });
+        } else {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const cookie: any = tough.Cookie.parse(headers['set-cookie']);
+            this.#cookiejar.setCookieSync(cookie, endpoint);
+        }
+
+        return this.#cookiejar.getCookies(endpoint);
+    };
+
+    GetCookiesFromJar = async (endpoint: string): Promise<tough.Cookie[]> =>
+    {
+        return this.#cookiejar.getCookies(endpoint);
+    };
+
+    ValidateJWT = async (token: string, audience: string, endpoint?: string): Promise<string> => {
+        const jwksClientUri = (endpoint 
+            ? `${endpoint}${goptions.asoauthapiroot}${goptions.asjwksjsonpath}` 
+            : `${goptions.asendpoint}:${goptions.asport}${goptions.asoauthapiroot}${goptions.asjwksjsonpath}`);
+
+        const jwks = jwksClient({
+            cache: true, //@@ all config items
+            cacheMaxEntries: 5, // Default value
+            cacheMaxAge: 600000, // Defaults to 10m
+            rateLimit: true,
+            jwksRequestsPerMinute: 10, // Default value
+            jwksUri: jwksClientUri,
+            timeout: 30000, //@@ config
+            requestAgent: this.#GetHttpsAgent()
+        });
+
+        // Use decode to get the kid
+        const decodedRefreshToken = jwtDecode<JSONObject>(token, { header: true });
+        const kid = decodedRefreshToken.kid;
+
+        const key = await jwks.getSigningKey(kid);
+        const signingKey = key.getPublicKey();
+		
+        const verifyOptions = {
+            issuer:  'https://stsmda.com.au/stsauth/',
+            //subject:  s,
+            audience:  audience,
+            //expiresIn:  600, // 10 minutes
+            algorithm:  ["RS256"]   // RSASSA [ "RS256", "RS384", "RS512" ]
+        };
+
+        return jwt.verify(token, signingKey, verifyOptions) as string;
+    }
+
+    // Function to extract the origin from a URI
+    ExtractOrigin = (uri: string) => {
+        const match = uri.match(this.#originRegex);
+        return match ? match[1] : null;
+    }
+
+    /**
+     * 
+     * @param clientId 
+     * @param authClientSecret 
+     * @param scope space seperate list of fully qualifed required scopes (i.e. api://<<api id>>/<<resource>>.<<permission>>). Note the scopes must all be for the same client api.
+     * @param endPoint 
+     * @returns 
+     */
+    GetAPITokenFromAuthServerUsingScope = async (clientId: string, authClientSecret: string, scope: string, endPoint?: string): Promise<string> => {
+        try {
+            const scopes = scope.split(' ');
+            let origin: string | null = null;
+            scopes.forEach((s) => {
+                if (!origin) {
+                    origin = this.ExtractOrigin(s);
+                    if (!origin) {
+                        throw new Error(`Scope: [${scope}] not in required format. Must use (space seperated) api://<client id>[/<resource>.<permission>].`);
+                    }
+                } else {
+                    const nextOrigin: string | null = this.ExtractOrigin(s);
+                    if (!nextOrigin) {
+                        throw new Error(`Scope: [${scope}] not in required format. Must use (space seperated) api://<client id>[/<resource>.<permission>].`);
+                    } else {
+                        if (origin.localeCompare(nextOrigin) !== 0) {
+                            throw new Error(`Scope: [${scope}] not all from the same client API. All scopes must come from the same client API.`);
+                        }
+                    }
+                }
+            });
+
+            const headers = { 'Content-Type': 'application/json'};
+            const payload = { //@@ make a type
+                client_id: clientId, // The service calling this method
+                client_secret: authClientSecret, // Auth service client secret
+                //client_secret: goptions.brokerclientsecret, // Broker service client secret
+                scope: scope, // required API
+                //@@ remove audience
+                //@@ need scope to be the API identifier
+                grant_type: "client_credentials"
+            }
+            const url = (endPoint 
+                ? `${endPoint}${goptions.asoauthapiroot}/token`
+                : `${goptions.asendpoint}:${goptions.asport}${goptions.asoauthapiroot}/token`);
+            const retVal = await axios({
+                url
+                ,method: 'post'
+                ,data: payload
+                ,headers: headers
+                ,httpsAgent: this.#GetHttpsAgent()
+            });
+
+            if (retVal.status) {
+                if (retVal.status !== 200) {
+                    // Just provide a warning here
+                    this.#debug(chalk.magenta(`Error (AuthUtilsNode:GetAPITokenFromServer): Invalid response from server: [${retVal.status}]`));
+                }
+            } else {
+                const msg = chalk.red(`Error (AuthUtilsNode:GetAPITokenFromServer:No retVal.status)`);
+                this.#debug(msg);
+                throw new Error(msg);
+            }
+            if (retVal.data) {
+                if (retVal.data.access_token) {
+                    return retVal.data.access_token as string;
+                } else {
+                    const msg = chalk.red(`Error (AuthUtilsNode:GetAPITokenFromServer:No retVal.data.access_token)`);
+                    this.#debug(msg);
+                    throw new Error(msg);
+                }
+            } else {
+                const msg = chalk.red(`Error (AuthUtilsNode:GetAPITokenFromServer:No retVal.data)`);
+                this.#debug(msg);
+                throw new Error(msg);
+            }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        } catch (error: any) {
+            this.#debug(chalk.red(`Error (AuthUtilsNode:GetAPITokenFromServer:catch): ${error}`));
+            if (error.response && error.response.data) {
+                this.#debug(chalk.red(`Details: [${JSON.stringify(error.response.data)}]`));
+            }
+            throw error;
+        }
+    }
+
+    /*
+	#getHttpsAgent = () =>
+	{
+		if (this.#httpsAgent === null) {
+			// https://nodejs.org/api/http.html#class-httpagent
+			this.#httpsAgent = new https.Agent({ 
+				keepAlive: goptions.keepAlive,
+				maxSockets: goptions.maxSockets,
+				maxTotalSockets: goptions.maxTotalSockets,
+				maxFreeSockets: goptions.maxFreeSockets,
+				timeout: goptions.timeout,
+				rejectUnauthorized: goptions.isProduction // Allows self signed certs in non production mode(s)
+			});
+		}
+		return this.#httpsAgent;
+	}
+
+	Login = async (opts) =>
+	{
+		const { authendpoint, authUserName, authUserEMail, authUserPassword, defaultTimeout, publishDebug } = opts;
+		try {
+			const processStart = performance.now();
+			let duration = '';
+			let loginData = null;
+			const payload = { name: authUserName, password: authUserPassword, email: authUserEMail }
+			const retVal = await axios({
+				url: `${authendpoint}/login` 
+				,method: 'post'
+				,data: payload
+				,timeout: defaultTimeout
+				,httpsAgent: this.#getHttpsAgent()
+				// Use below if using a socket endpoint
+				//,socketPath: '/var/run/sts/stsrest01.sock'
+			});
+			duration = (performance.now() - processStart).toFixed(4);
+			if (publishDebug) debug(`AuthUtilsNode.LoginNode request duration: [${duration}]`);
+			loginData = retVal.data.detail;
+
+
+			if (retVal.headers['set-cookie'] instanceof Array) {
+				this.#cookies = retVal.headers['set-cookie'].map(cookie.parse);
+			} else {
+				this.#cookies = [cookie.parse(retVal.headers['set-cookie'])];
+			}
+
+			//await this.SetCookiesToJar(retVal.headers);
+
+			return loginData;
+		} catch (error)
+		{
+			if (publishDebug) debug(chalk.red(`Error (AuthUtilsNode:LoginNode): ${error}`));
+			throw error;
+		}
+	}
+
+	// https://stackoverflow.com/questions/43002444/make-axios-send-cookies-in-its-requests-automatically
+	// axios.get('some api url', {withCredentials: true});
+	// https://medium.com/@adityasrivast/handling-cookies-with-axios-872790241a9b
+	// https://www.codegrepper.com/code-examples/javascript/axios+send+cookies
+	// http only cookies
+	RefreshSessionToken = async (opts) =>
+	{
+		const { authendpoint, defaultTimeout, publishDebug } = opts;
+		try {
+			const processStart = performance.now();
+			let duration = '';
+			let loginData = null;
+			const cookies = await this.GetCookiesFromJar();
+			const retVal = await axios({
+				url: `${authendpoint}/refreshtoken`
+				,method: 'post'
+				,headers: {
+					Cookie: cookies
+				}
+				,timeout: defaultTimeout
+				,httpsAgent: this.#httpsAgent,
+				// Use below for socket connections
+				//,socketPath: '/var/run/sts/stsrest01.sock'
+			});
+			duration = (performance.now() - processStart).toFixed(4);
+			if (publishDebug) debug(`AuthUtilsNode.RefreshAuthTokenBrowser request duration: [${duration}]`);
+			loginData = retVal.data.detail;
+			await this.SetCookiesToJar(retVal.headers);
+			return loginData;
+		} catch (error) {
+			if (publishDebug) debug(chalk.red(`Error (AuthUtilsNode:RefreshAuthTokenBrowser): ${error}`));
+			throw error;
+		}
+	}
+	*/
+}

package/src_new/commonTypes.ts

@@ -0,0 +1,239 @@
+/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
+import { Server, Socket, Namespace } from "socket.io";
+
+import { STSOptionsBase, JSONObject } from "@nsshunt/stsutils"
+import { PublishInstrumentControllerV2, InstrumentDefinitions } from '@nsshunt/stspublisherserver'
+import { InstrumentBaseTelemetry, Gauge, InstrumentBase } from '@nsshunt/stsinstrumentation'
+import { PGAccessLayer } from '@nsshunt/stsdatamanagement'
+import { STSDefaultClientToServerEvents, STSDefaultServerToClientEvents } from '@nsshunt/stssocketio-client'
+import { Consumer, IHeaders } from 'kafkajs'
+
+export enum IPCMessageCommand {
+    AddWorker = 'AddWorker',
+    DeleteWorker = 'DeleteWorker'
+}
+
+export interface IPCMessagePayload {
+	requestResponse: boolean,
+	id: string,
+    command: IPCMessageCommand,
+	requestDetail?: JSONObject,
+    responseDetail?: JSONObject
+}
+
+export interface IPCMessage {
+	iPCMessagePayload: IPCMessagePayload
+	cb: () => void,
+	timeout: NodeJS.Timeout
+}
+
+export type IPCMessages = Record<string, IPCMessage>
+
+//------------------------------------
+
+export interface IProcessBase extends STSOptionsBase {
+    SetupInstrumentation(): void
+    GetAdditionalInstruments(): InstrumentDefinitions
+    CollectAdditionalTelemetry(): void
+    ProcessStartup: () => void
+    UpdateInstrument: (instrumentName: Gauge, telemetry: InstrumentBaseTelemetry) => void
+    get InstrumentController(): PublishInstrumentControllerV2 | null
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any    
+    LogEx: (message: any) => void
+    InstrumentExists(instrumentName: Gauge): boolean
+    ProcessTerminate: () => Promise<void>
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    GetUIController(): any
+    get socketIoServerHelper(): ISocketIoServerHelper<STSDefaultClientToServerEvents, STSDefaultServerToClientEvents> | null
+    set socketIoServerHelper(value: ISocketIoServerHelper<STSDefaultClientToServerEvents, STSDefaultServerToClientEvents> | null)
+    TerminateDatabase(): Promise<void>
+    get accessLayer(): PGAccessLayer | null
+    get shuttingDown(): boolean
+}
+
+export interface IMasterProcessBase extends IProcessBase {
+    // eslint-disable-next-line  @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars
+    WorkerMessageEvent(msg: any): any
+    SetupServer: () => Promise<void>
+    SetupServerEx: () => Promise<void>
+    // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+    KillWorker: (id: string, signal: NodeJS.Signals, options: any, killProcess: boolean, allowKillAll: boolean) => boolean
+    KillWorkers: (signal: NodeJS.Signals) => void
+    IncWorkers: () => void
+    DecWorkers: () => void
+    // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+    AddWorker: (options: any) => number
+    MasterStarted(): void
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    BroadcastDataToWorkers: (command: any, data: any) => void
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ProcessTerminating(): Promise<void>
+}
+
+export interface ISingleProcessBase extends IProcessBase {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    get httpServer(): any
+    CollectAdditionalTelemetry(): void
+    ProcessStarted(): any
+    get io(): any
+    ProcessTerminating(): Promise<void>
+    get expressServer(): any // STSExpressServer - need to put interface in common types - circular reference
+    SetupServer(): Promise<boolean>
+    SetupServerEx: () => Promise<void>
+    TerminateApplication(): Promise<void>
+}
+
+export interface IWorkerProcessBase extends IProcessBase {
+    get httpServer(): any
+    WorkerStarted(): any
+    // eslint-disable-next-line  @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars
+    ReceivedMessageFromMaster(msg: any): void
+    CollectAdditionalTelemetry(): void
+    get io(): any
+    // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+    AddWorker: (options: any) => Promise<string>
+    // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+    DeleteWorker: (workerId: string, options: any) => Promise<JSONObject>
+    ProcessTerminating(): Promise<void>
+    get expressServer(): any
+    SetupServer: () => Promise<void>
+    SetupServerEx: () => Promise<void>
+}
+
+// -----------------------------------------------------------------------------
+
+export type ServerEventCb = (socket: any, data: any) => void
+
+export interface ServerSocketEvent {
+	serverEventName: string,
+	serverEventCb: ServerEventCb
+}
+
+export enum STSNamespace {
+	STSMonitor = 'stsmonitor',
+	STSControl = 'stscontrol'
+}
+
+export enum STSRoom {
+	// STSMonitor rooms
+	STSInstrumentDataRoom = 'stsinstrumentdataroom', // This room is for all instrument data messages
+	STSInstrumentDataSubscriptionRoom = 'stsinstrumentdatasubscriptionroom', // This room is only for subscribed instrument data messages
+
+	// STSControl rooms
+	STSRunnerRoom = 'stsrunnerroom',
+	STSNodeRunnerRoom = 'stsnoderunnerroom'
+}
+
+export enum STSEvent {
+	// STSInstrumentData
+	STSInstrumentData = 'stsinstrumentdata',
+	STSSubInstrumentData = 'stssubinstrumentdata', // sub-scribed instrument data. This only outputs the nodes that have been subscribed by the client(s).
+	STSResetInstrumentData = 'stsresetinstrumentdata',
+
+	STSStartLoggingInstrumentData = 'stsStartLoggingInstrumentData',
+	STSStopLoggingInstrumentData = 'stsStopLoggingInstrumentData',
+
+	// STSRunner events
+	STSStart = 'stsstart', // Start a test run with options as payload.
+	STSStop = 'stsstop', // Stop test run(s).
+	STSPause = 'stspause', // Pause test run(s).
+	STSResume = 'stsresume', // Resume test run(s).
+	STSTerminate = 'ststerminate', // Terminate runner instances and exit applications.
+	// This may also be uysed to force trigger self healing (i.e. auto re-start) when
+	// running within a container orchestrator such as K8, K3 or Docker Swarm.
+	STSUpdateStaticConfig = 'stsupdatestaticconfig', // Update base configuration. Options as payload.
+	STSUpdateDynamicConfig = 'stsupdatedynamicconfig', // Update running configuration. This is used
+	// to control the runnning behaviour of test(s) in-flight. Options as payload.
+
+	STSSendToRoom = 'sendToRoom',
+
+	// Standard socket events
+	connect = 'connect'
+}
+
+// https://socket.io/docs/v4/typescript/
+
+export interface InterServerEvents {
+	ping: () => void;
+}
+
+export interface STSSocketIONamespace {
+	namespace: string
+	pid: number
+	socketionamespace: Namespace<STSDefaultClientToServerEvents, STSDefaultServerToClientEvents, InterServerEvents>
+}
+
+export type STSServerSocket = Socket<STSDefaultClientToServerEvents, STSDefaultServerToClientEvents, InterServerEvents>
+export type STSClientSocket = Socket<STSDefaultServerToClientEvents, STSDefaultClientToServerEvents, InterServerEvents>
+
+export interface ISocketIoServerHelper<ClientToServerEvents extends STSDefaultClientToServerEvents, ServerToClientEvents extends STSDefaultServerToClientEvents>
+{
+    LogMessage: (namespace: STSSocketIONamespace, message: string) => void
+    LeaveRoom: (namespace: STSSocketIONamespace, socket: STSServerSocket, room: STSRoom) => void
+    JoinRoom: (namespace: STSSocketIONamespace, socket: STSServerSocket, room: STSRoom) => void
+    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>
+    GetSTSSocketIONamespace: (namespace: any) => STSSocketIONamespace
+    DisconnectSockets: () => void
+    SetupEvent(event: ClientToServerEvents, eventCb: ServerEventCb): ISocketIoServerHelper<ClientToServerEvents, ServerToClientEvents>
+}
+
+export interface IInfluxDBManagerOptions {
+    token: string // API access token
+    url: string // end-pont for API
+    org: string // organisation
+    bucket: string // bucket to store results
+    agent?: {
+        influxDB_keepAlive: boolean
+        influxDB_maxSockets?: number
+        influxDB_maxTotalSockets?: number
+        influxDB_maxFreeSockets?: number
+        influxDB_timeout?: number
+        influxDB_rejectUnauthorized?: boolean
+    }
+}
+
+export type Nid = string;
+
+export interface ContextBase extends JSONObject {
+	nid?: Nid
+}
+
+export interface ServiceProcessContext extends ContextBase {
+	serviceId?: string // Service name and the service version
+
+	serviceInstanceId?: string // Service unique id and the host name
+	sid?: string // Service unique id only, does not include host
+	hostName?: string // Service Instance Host Name
+
+	// Left level attributes
+	serviceInstanceProcessId?: string // Service Instance OS Process ID (parent process id)
+	pid?: number // Service Instance OS Process ID (parent process id)
+	ppid?: number// Service Instance OS Parent Process ID if worker. Will be pid if parent process.
+	isMaster?: boolean // True if is Master Process
+	isWorker?: boolean // True if is Worker Process
+	serviceName?: string // Defined in .env or environment variable
+	serviceVersion?: string // Defined in .env or environment variable
+}
+
+export interface InstrumentPayload {
+	//nid: string
+	context: ServiceProcessContext
+	instruments: Record<string, InstrumentBase>
+}
+
+export interface IKafkaConsumer {
+    get consumer(): Consumer
+    get id(): string
+    Connect(): Promise<void>
+    Disconnect(): Promise<void>
+    Subscribe: (topics: string[], fromBeginning: boolean) => Promise<void>
+    Stop: () => Promise<void>
+    StartConsumingMessages: (cb: (topic: string, key: string, partition: number, value: string, headers: IHeaders | undefined) => void) => Promise<void>
+}
+
+export type logFunction = (msg: any) => void
+

package/src_new/index.ts

@@ -0,0 +1,22 @@
+export * from './commonTypes'
+export * from './processoptions'
+export * from './authDefs'
+export * from './authutilsnode'
+export * from './stsrouterbase'
+export * from './stscontrollerbase'
+export * from './singleprocessbase'
+export * from './masterprocessbase'
+export * from './workerprocessbase'
+export * from './socketIoServerHelper'
+export * from './stslatencycontroller'
+export * from './stslatencyroute'
+export * from './kafka/kafkamanager'
+export * from './kafka/kafkaproducer'
+export * from './kafka/kafkaconsumer'
+export * from './kafka/IMKafkaManager'
+export * from './influxdb/influxDBManager'
+export * from './influxdb/influxDBManagerBase'
+export * from './influxdb/influxDBManagerService'
+export * from './influxdb/influxDBManagerAgent'
+export * from './publishertransports/publishTransportUtils'
+export * from './instrumentationsubscriber'