@nsshunt/stsappframework 3.1.209 → 3.1.211

package/src/ipcMessageManager.ts

@@ -1,171 +0,0 @@
-/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
-import { ISTSLogger, JSONObject } from '@nsshunt/stsutils'
-
-import { v4 as uuidv4 } from 'uuid';
-
-import { IIPCMessageProcessorIPCPayload, IIPCMessageProcessorWorkerRecord } from './commonTypes'
-
-export interface IPCMessageManagerOptions {
-    logger: ISTSLogger
-    requestResponseMessageTimeout: number
-    namespace: string
-    role: 'SERVER' | 'CLIENT'
-    groups: string[]
-    messageSender: (payload: IIPCMessageProcessorIPCPayload, options: any) => void
-    ProcessRequestMessage: (payload: IIPCMessageProcessorIPCPayload, options: any) => Promise<JSONObject>
-    ProcessResponseMessage?: (reesponses: Record<string, IIPCMessageProcessorIPCPayload>, options: any) => Promise<boolean>
-    messageReceiverStart: (options: any) => void
-    messageReceiverStop: (options: any) => void
-}
-/**
- * todo
- * @typedef {Object} options - todo
- * @property {boolean} [wssServer=false] - Create a web socket server on this worker instance
- */
-export class IPCMessageManager
-{
-    #id: string;
-    #options: IPCMessageManagerOptions;
-    #inflightMessages: Record<string, IIPCMessageProcessorWorkerRecord> = { };
-    #messageHeader: string;
-
-    constructor(options: IPCMessageManagerOptions) {
-        this.#id = uuidv4();
-        this.#options = options;
-        this.#messageHeader = `__STS__${this.#options.namespace}__${uuidv4()}`;
-    }
-
-    get id() {
-        return this.#id;
-    }
-
-    // eslint-disable-next-line  @typescript-eslint/no-unused-vars
-    ReceivedMessageFromMaster(msg: any) {
-        // Override in subclass if required
-    }
-
-    SendMessage = (payload: JSONObject, options?: any): Promise<JSONObject> => {
-        return new Promise((resolve, reject) => {
-            this.#SendMessage(payload, options,
-                (payload: IIPCMessageProcessorIPCPayload) => {
-                    resolve(payload.responsePayload);
-                },
-                (payload: IIPCMessageProcessorIPCPayload) => {
-                    reject(payload.requestPayload);
-                })
-        })
-    }
-
-    #SendMessage = (payload: JSONObject, options: any,
-        callBack: (payload: IIPCMessageProcessorIPCPayload) => void, 
-        errorCallBack: (payload: IIPCMessageProcessorIPCPayload) => void
-    ): void => {
-        const messageId: string = uuidv4();
-        const requestPayload: IIPCMessageProcessorIPCPayload = {
-            header: this.#messageHeader,
-            messageId,
-            senderId: this.#id,
-            senderRole: this.#options.role,
-            requestPayload: payload,
-            responsePayload: { },
-            pid: process.pid.toString(),
-            messageType: 'REQUEST'
-        }
-        const messageRecord = {
-            messageId,
-            senderId: this.#id,
-            senderRole: this.#options.role,
-            requestPayload,
-            responses: { }, // record
-            startTime: performance.now(),
-            endTime: 0,
-            timeout: setTimeout(() => {
-                //this.#LogDebugMessage(chalk.red(`Timeout has occurred after: [${this.#options.requestResponseMessageTimeout}]ms with message id: [${messageRecord.messageId}]. Details: [${JSON.stringify(this.#inflightMessages[messageRecord.messageId].requestPayload)}]`));
-                setTimeout(() => {
-                    delete this.#inflightMessages[messageRecord.messageId];
-                }, 0).unref();
-                errorCallBack(requestPayload);
-            }, this.#options.requestResponseMessageTimeout).unref(),// max message timeout allowed
-            callBack,
-            errorCallBack
-        }
-        this.#inflightMessages[messageRecord.messageId] = messageRecord;
-        //this.#LogDebugMessage(chalk.cyan(`sending: [${JSON.stringify(requestPayload)}]`));
-        this.#options.messageSender(requestPayload, options);
-    }
-
-    #ProcessMessage = async (msg: any, options: any): Promise<void> => {
-        if (msg.header && msg.header.localeCompare(this.#messageHeader) === 0) {
-            const message = (msg as IIPCMessageProcessorIPCPayload);
-            if (this.#inflightMessages[message.messageId]) {
-                const inFlightMessageRecord: IIPCMessageProcessorWorkerRecord = this.#inflightMessages[message.messageId];
-                inFlightMessageRecord.responses[message.senderId ] = { ...message };
-                let completed = true; // Defaults to true
-                if (this.#options.ProcessResponseMessage) {
-                    completed = await this.#options.ProcessResponseMessage(inFlightMessageRecord.responses, options);
-                    if (completed) {
-                        inFlightMessageRecord.endTime = performance.now();
-                        clearTimeout(inFlightMessageRecord.timeout as NodeJS.Timeout);
-                        inFlightMessageRecord.callBack({
-                            responsePayload: Object.values(inFlightMessageRecord.responses).map(r => r.responsePayload)
-                        } as any, options) // 
-                        delete this.#inflightMessages[message.messageId];
-                    }
-                } else if (completed) {
-                    inFlightMessageRecord.endTime = performance.now();
-                    clearTimeout(inFlightMessageRecord.timeout as NodeJS.Timeout);
-                    inFlightMessageRecord.callBack(message, options) // inFlightMessageRecord.responses
-                    //@@inFlightMessageRecord.callBack(Object.values(inFlightMessageRecord.responses), options) // 
-                    delete this.#inflightMessages[message.messageId];
-                } else {
-                    //console.log(chalk.grey(`#ProcessMessage:5`));
-                }
-            } else {
-                //throw new Error(`Could not find Request/Response message with id: [${message.messageId}]`); //@@
-            }
-        }
-    }
-
-    Start = (options?: any) => {
-        this.#messageHeader = `__STS__${this.#options.namespace}__${uuidv4()}`;
-        this.#options.messageReceiverStart(options);
-    }
-
-    Stop = (options?: any) => {
-        // Kill in-flight messages
-        this.#options.messageReceiverStop(options);
-
-        for (const [, iPCMessageProcessorWorkerRecord] of Object.entries(this.#inflightMessages)) {
-            if (iPCMessageProcessorWorkerRecord.timeout) {
-                clearTimeout(iPCMessageProcessorWorkerRecord.timeout);
-            }
-        }
-        this.#inflightMessages = { };
-    }
-
-    // Process a message recieved from a worker
-    ProcessMessage = async (msg: any, options: any) => {
-        if (msg.header) {
-            const checkName = `__STS__${this.#options.namespace}__`; //@@ this is a broadcast becuase the unique uuid is not part of the header test
-            if ((msg.header as string).includes(checkName)) {
-                const message = (msg as IIPCMessageProcessorIPCPayload);
-                if (msg.messageType.localeCompare('REQUEST') === 0) {
-                    let processMessage = true;
-                    if (message.requestPayload.args && message.requestPayload.args.length > 0 && message.requestPayload.args[0].group) {
-                        const group = message.requestPayload.args[0].group;
-                        processMessage = (this.#options.groups.indexOf(group) === -1) ? false : true;
-                    }
-                    if (processMessage) {
-                        message.responsePayload = await this.#options.ProcessRequestMessage(message, options);
-                        message.senderId = this.#id;
-                        message.messageType = 'RESPONSE';
-                        this.#options.messageSender(message, options);
-                    }
-                } else {
-                    // Received a response (to my request)
-                    this.#ProcessMessage(msg, options);
-                }
-            }
-        }
-    }
-}

package/src/ipcMessageProcessorPrimary.ts

@@ -1,76 +0,0 @@
-/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
-import { ISTSLogger, JSONObject, defaultLogger } from '@nsshunt/stsutils'
-
-import { Worker } from 'node:cluster';
-
-import { IIPCMessageProcessorIPCPayload } from './commonTypes'
-
-import { IPCMessageManager, IPCMessageManagerOptions } from './ipcMessageManager'
-
-export interface IIPCMessageProcessorPrimary {
-    logger: ISTSLogger
-    namespace: string
-    processPayload?: (payload: IIPCMessageProcessorIPCPayload, options: any) => Promise<JSONObject>
-}
-
-/**
- * IPC Message Handling.
- * 
- * This class can be used to support messages between cluster.primary and cluster.worker instances using IPC.
- * This class can be used for finer control for processing messages between the cluster primary and cluster workers.
- * Use the ipcMessageHandler for a simpler implementation.
- * This class is used for the cluster primary thread only.
- * Note: Currently groups handling is not supported. Use the redis version for this capability.
- */
-export class IPCMessageProcessorPrimary {
-    #ipcMessageManager: IPCMessageManager;
-    #worker: Worker | null = null;
-
-    constructor(classOptions: IIPCMessageProcessorPrimary) {
-        const ipcMessageManagerOptions: IPCMessageManagerOptions = {
-            logger: defaultLogger,
-            requestResponseMessageTimeout: 5000,
-            namespace: classOptions.namespace,
-            role: 'SERVER',
-            messageSender: (payload: IIPCMessageProcessorIPCPayload, options: any) => {
-                (options.worker as any).send(payload);
-            },
-            ProcessRequestMessage: async (payload: IIPCMessageProcessorIPCPayload, options: any): Promise<JSONObject> => {
-                if (classOptions.processPayload) {
-                    return classOptions.processPayload(payload, options);
-                } else {
-                    return { };
-                }
-            },
-            messageReceiverStart: (options: any) => {
-                // Receive a message to process from a worker
-                const worker = (options.worker as Worker);
-                worker.on('message', (payload) => this.#ipcMessageManager.ProcessMessage(payload, { worker }));
-            },
-            messageReceiverStop: (options: any) => {
-                const worker = (options.worker as Worker);
-                worker.off('message', (payload) => this.#ipcMessageManager.ProcessMessage(payload, { worker }));
-            },
-            groups: [ ]
-        }
-        this.#ipcMessageManager = new IPCMessageManager(ipcMessageManagerOptions);
-    }
-
-    SendMessage = async (payload: JSONObject): Promise<JSONObject> => {
-        return this.#ipcMessageManager.SendMessage(payload, { worker: this.#worker });
-    }
-
-    Start = (worker: Worker) => {
-        this.#ipcMessageManager.Start({ worker });
-        this.#worker = worker;
-    }
-
-    Stop = () => {
-        this.#ipcMessageManager.Stop({ worker: this.#worker });
-        this.#worker = null;
-    }
-
-    get worker(): Worker | null {
-        return this.#worker;
-    }
-}

package/src/ipcMessageProcessorWorker.ts

@@ -1,70 +0,0 @@
-/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
-import { ISTSLogger, JSONObject, defaultLogger } from '@nsshunt/stsutils'
-
-import { IIPCMessageProcessorIPCPayload } from './commonTypes'
-
-import { IPCMessageManager, IPCMessageManagerOptions } from './ipcMessageManager'
-
-export interface IIPCMessageProcessorWorker {
-    logger: ISTSLogger
-    requestResponseMessageTimeout: number
-    namespace: string
-    processPayload?: (payload: IIPCMessageProcessorIPCPayload, options: any) => Promise<JSONObject>
-}
-
-/**
- * IPC Message Handling.
- * 
- * This class can be used to support messages between cluster.primary and cluster.worker instances using IPC.
- * This class can be used for finer control for processing messages between the cluster primary and cluster workers.
- * Use the ipcMessageHandler for a simpler implementation.
- * This class is used for the cluster worker threads only.
- * Note: Currently groups handling is not supported. Use the redis version for this capability.
- */
-export class IPCMessageProcessorWorker {
-    #ipcMessageManager: IPCMessageManager;
-
-    constructor(classOptions: IIPCMessageProcessorWorker) {
-        const ipcMessageManagerOptions: IPCMessageManagerOptions = {
-            logger: defaultLogger,
-            requestResponseMessageTimeout: classOptions.requestResponseMessageTimeout,
-            namespace: classOptions.namespace,
-            role: 'CLIENT',
-            // eslint-disable-next-line  @typescript-eslint/no-unused-vars
-            messageSender: (payload: IIPCMessageProcessorIPCPayload, options: any) => {
-                // Options not required for sending payloads to the master process
-                (process as any).send(payload);
-            },
-            ProcessRequestMessage: async (payload: IIPCMessageProcessorIPCPayload, options: any): Promise<JSONObject> => {
-                if (classOptions.processPayload) {
-                    return classOptions.processPayload(payload, options);
-                } else {
-                    return { };
-                }
-            },
-            messageReceiverStart: (options: any) => {
-                // Receive a message response back from the primary thread
-                process.on('message', (payload) => {
-                    this.#ipcMessageManager.ProcessMessage(payload, options);
-                });
-            },
-            messageReceiverStop: (options: any) => {
-                process.off('message', (payload) => this.#ipcMessageManager.ProcessMessage(payload, options));
-            },
-            groups: [ ]
-        }
-        this.#ipcMessageManager = new IPCMessageManager(ipcMessageManagerOptions);
-    }
-    
-    SendMessage = async (payload: JSONObject): Promise<JSONObject> => {
-        return this.#ipcMessageManager.SendMessage(payload, { });
-    }
-
-    Start = () => {
-        this.#ipcMessageManager.Start({ });
-    }
-
-    Stop = () => {
-        this.#ipcMessageManager.Stop({ });
-    }
-}

package/src/messagehandling/webWorkerMessageHandler.ts

@@ -1,341 +0,0 @@
-/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF */  // --> OFF
-import { TinyEmitter } from "tiny-emitter";
-import { ISTSLogger, JSONObject } from '@nsshunt/stsutils'
-
-import { IIPCMessageProcessorIPCPayload, IServiceProcessContext, ProcessOptions } from '../commonTypes'
-
-import { IPCMessageManager, IPCMessageManagerOptions } from '../ipcMessageManager'
-
-import chalk from 'chalk';
-
-import { MessagePort } from 'worker_threads';
-
-export interface IWebWorderMessageHandlerOptions {
-    logger: ISTSLogger
-    role: 'SERVER' | 'CLIENT'
-    namespace: string
-    groups: string[]
-    ignoreEvents?: string[]
-    processOptions?: ProcessOptions
-    messagePort: MessagePort
-}
-
-export interface IClientRecord {
-    id: string
-    clientConnected: Date
-    pingCount: number
-    timeout: NodeJS.Timeout
-    groups: string[]
-    serviceProcessContext?: IServiceProcessContext
-}
-
-export interface IEventPayload {
-    __eventName: string
-    args: any[]
-}
-
-export interface IEventRecord {
-    event: string
-    callback: any,
-    ctx?: any
-}
-
-export interface IPingData {
-    id: string
-    groups: string[]
-    serviceProcessContext?: IServiceProcessContext
-}
-
-export class WebWorkerMessageHandler extends TinyEmitter {
-    #ipcMessageManager: IPCMessageManager | null = null;
-    #options: IWebWorderMessageHandlerOptions;
-    #events: Record<string, IEventRecord> = { };
-    #clients: Record<string, IClientRecord> = { };
-    #pingTimeout: NodeJS.Timeout | null = null;
-    #messagePort: MessagePort;
-
-    constructor(options: IWebWorderMessageHandlerOptions) {
-        super();
-        this.#options = options;
-        this.#messagePort = options.messagePort;
-
-        this.SetupPrimary();
-
-        if (this.#options.role.localeCompare('CLIENT') === 0) {
-            const ping = () => {
-                this.#pingTimeout = setTimeout(() => {
-                    const pingData: IPingData = {
-                        id: (this.#ipcMessageManager as IPCMessageManager).id,
-                        groups: this.#options.groups,
-                    }
-                    if (this.#options.processOptions) {
-                        pingData.serviceProcessContext = this.#options.processOptions.serviceProcessContext;
-                    }
-                    this.emit('ping', pingData, (response: any) => { });
-                    ping();
-                }, 1000).unref();
-            }
-            ping();
-        } else {
-            this.on('ping', (pingData: IPingData, callback: any) => {
-                const { id, groups, serviceProcessContext } = pingData;
-                if (this.#clients[id]) {
-                    clearTimeout(this.#clients[id].timeout);
-                    this.#clients[id].pingCount++;
-                    this.#clients[id].timeout = setTimeout(() => {
-                        delete this.#clients[id];
-                    }, 2000);
-                    this.#clients[id].groups = groups;
-                    this.#clients[id].serviceProcessContext = serviceProcessContext;
-                } else {
-                    this.#clients[id] = {
-                        id,
-                        clientConnected: new Date(),
-                        pingCount: 0,
-                        timeout: setTimeout(() => {
-                            delete this.#clients[id];
-                        }, 2000),
-                        groups,
-                        serviceProcessContext
-                    }
-                }
-                callback('ok');
-            });
-        }
-    }
-
-    #processRawMessage = (rawmessage: string) => {
-        const message = JSON.parse(rawmessage);
-        this.#ipcMessageManager?.ProcessMessage(message, { });
-    }
-
-    get clients(): Record<string, IClientRecord> {
-        return this.#clients;
-    }
-
-    get groups(): string[] {
-        return this.#options.groups;
-    }
-    
-    AddGroup = (group: string) => {
-        const index = this.#options.groups.indexOf(group);
-        if (index === -1) {
-            this.#options.groups.push(group);
-        }
-    }
-
-    RemoveGroup = (group: string) => {
-        const removeIndex = this.#options.groups.indexOf(group);
-        if (removeIndex !== -1) {
-            this.#options.groups.splice(removeIndex, 1);
-        }
-    }
-
-    SetupPrimary = () => {
-        const ipcMessageManagerOptions: IPCMessageManagerOptions = {
-            logger: this.#options.logger,
-            requestResponseMessageTimeout: 5000,
-            namespace: this.#options.namespace,
-            role: this.#options.role,
-            messageSender: this.#messageSender,
-            groups: this.#options.groups,
-            // This method is used to calculate if all responses have been received from multiple clients (broadcast)
-            // returns true/false.
-            ProcessResponseMessage: this.#ProcessResponseMessage,
-            // This gets called when an event is received from a message receiver (when ProcessMessage is invoked from the receiver event handler)
-            ProcessRequestMessage: this.#processPayload,
-             
-            messageReceiverStart: (options: any) => {
-                this.#messagePort.on('message', this.#processRawMessage);
-                //this.#redisSubscriber.on("message", this.#processRawMessage);
-            },
-             
-            messageReceiverStop: (options: any) => {
-                this.#messagePort.off("message", this.#processRawMessage);
-                //this.#redisSubscriber.off("message", this.#processRawMessage);
-            }
-        }
-        this.#ipcMessageManager = new IPCMessageManager(ipcMessageManagerOptions);
-    }
-
-     
-    #messageSender = (payload: IIPCMessageProcessorIPCPayload, options: any) => {
-        if (payload.messageType.localeCompare('REQUEST') === 0) {
-            //this.#redisPublisher.publish(this.#requestChannel, JSON.stringify(payload));
-            this.#messagePort.postMessage(JSON.stringify(payload));
-        } else if (payload.messageType.localeCompare('RESPONSE') === 0) {
-            this.#messagePort.postMessage(JSON.stringify(payload));
-            //this.#redisPublisher.publish(this.#responseChannel, JSON.stringify(payload));
-        }
-    }
-
-     
-    #ProcessResponseMessage = async (responses: Record<string, IIPCMessageProcessorIPCPayload>, options: any): Promise<boolean> => {
-        // Now check if we have all responses ...
-        let allFound = false;
-
-        for (const [responseId, response] of Object.entries(responses)) {
-            if (response.senderRole.localeCompare('CLIENT') === 0) {
-                allFound = true;
-                break;
-            }
-        }
-        if (allFound) {
-            return allFound;
-        }
-
-        let found = true;
-
-        // Sender role here is SERVER
-        let requestGroup = null;
-        for (const [responseId, response] of Object.entries(responses)) {
-            if (response.requestPayload.args.length > 0 && response.requestPayload.args[0].group) {
-                requestGroup = response.requestPayload.args[0].group;
-                break;
-            }
-        }
-
-        if (requestGroup) {
-            const clientsInGroup = Object.values(this.#clients).filter(c => {
-                if (c.groups.indexOf(requestGroup) === -1) {
-                    return false;
-                }
-                return true;
-            });
-
-            // Now make sure that all clients are in the responses
-            found = true;
-            clientsInGroup.forEach(c => {
-                if (!responses[c.id]) {
-                    found = false;
-                }
-            })
-        } else {
-            const clientsInGroup = Object.values(this.#clients)
-
-            // Now make sure that all clients are in the responses
-            found = true;
-            clientsInGroup.forEach(c => {
-                if (!responses[c.id]) {
-                    found = false;
-                }
-            })
-        }
-
-        return found;
-    }
-
-    #processPayload = (payload: IIPCMessageProcessorIPCPayload, options: any): Promise<JSONObject> => {
-        // check the event name from the collection and invoke that function
-        return new Promise<JSONObject>((resolve, reject) => {
-            if (payload.messageType.localeCompare('REQUEST') === 0) {
-                if (payload.requestPayload['__eventName']) {
-                    const eventName = payload.requestPayload['__eventName'];
-                    // Only process events that I have registered interest in (using .on)
-                    if (this.#events[eventName]) {
-                        try {
-                            //const retVal = this.#events[eventName].callback(payload.requestPayload.args, payload, options, this.#events[eventName].ctx);
-                            this.#events[eventName].callback(...payload.requestPayload.args, (responseMessage: any) => {
-                                resolve(responseMessage);
-                            });
-                        } catch (error) {
-                            reject(error);
-                        }
-                    }
-                }
-            }
-        });
-    }
-
-    // p.on('fromworker', (arg1: number, arg2: string, callback: any) => {
-    override on(event: string, callback: any, ctx?: any): this {
-        if (this.#events[event]) {
-            // Update the event with the same name
-            delete this.#events[event];
-        }
-        const eventObject: IEventRecord = {
-            event,
-            callback,
-            ctx
-        }
-        this.#events[eventObject.event] = eventObject;
-        return this;
-    }
-
-    override off(event: string, callback?: any): this {
-        if (this.#events[event]) {
-            delete this.#events[event];
-        }
-        return this;
-    }
-
-    Start = () => {
-        this.#ipcMessageManager?.Start();
-    }
-
-    Stop = () => {
-        if (this.#pingTimeout) {
-            clearTimeout(this.#pingTimeout);
-            this.#pingTimeout = null;
-        }
-
-        this.#ipcMessageManager?.Stop();
-
-        /*
-        this.#redisSubscriber.quit();
-        this.#redisSubscriber.disconnect();
-
-        this.#redisPublisher.quit();
-        this.#redisPublisher.disconnect();
-        */
-    }
-
-    override emit(event: string, ...args: any[]): this {
-        (async () => {
-            try {
-                const retVal = await this.#ipcMessageManager?.SendMessage({
-                    __eventName: event,
-                    args: args.slice(0, args.length-1)
-                } as IEventPayload);            
-                // Invoke the response callback
-                args[args.length-1](retVal);
-            } catch (error) {
-                if (this.#options.ignoreEvents) {
-                    if (this.#options.ignoreEvents.indexOf((error as any).__eventName) !== -1) {
-                        return;
-                    }
-                }
-                this.#options.logger.error(chalk.red(`RedisMessageHandler:emit(): Error: [${JSON.stringify(error)}]`));
-            }
-        })();
-        return this;
-    }
-
-    emitWithError(event: string, args: JSONObject, responseCb: (response: JSONObject | undefined) => void, errorCb: (error: any) => void): this {
-        (async () => {
-            try {
-                const retVal = await this.#ipcMessageManager?.SendMessage({
-                    __eventName: event,
-                    args: [ args ]
-                } as IEventPayload);            
-                // Invoke the response callback
-                responseCb(retVal);
-            } catch (error) {
-                if (this.#options.ignoreEvents) {
-                    if (this.#options.ignoreEvents.indexOf((error as any).__eventName) !== -1) {
-                        return;
-                    }
-                }
-                errorCb(error);
-            }
-        })();
-        return this;
-    }
-
-    emitex = async(event: string, ...args: any[]): Promise<JSONObject> => {
-        return (this.#ipcMessageManager as IPCMessageManager).SendMessage({
-            __eventName: event,
-            args
-        } as IEventPayload);            
-    }
-}