@nsshunt/stsmessaging 1.0.56 → 1.0.57

package/dist/index.mjs

@@ -0,0 +1,699 @@
+import { TinyEmitter } from "tiny-emitter";
+import { Redis } from "ioredis";
+import chalk from "chalk";
+import { defaultLogger } from "@nsshunt/stsutils";
+//#region src/messagingManager.ts
+/**
+* todo
+* @typedef {Object} options - todo
+* @property {boolean} [wssServer=false] - Create a web socket server on this worker instance
+*/
+var MessagingManager = class {
+	#id;
+	#options;
+	#inflightMessages = {};
+	#messageHeader;
+	constructor(options) {
+		this.#id = globalThis.crypto.randomUUID();
+		this.#options = options;
+		this.#messageHeader = `__STS__${this.#options.namespace}__${globalThis.crypto.randomUUID()}`;
+	}
+	get id() {
+		return this.#id;
+	}
+	ReceivedMessageFromMaster(msg) {}
+	SendMessageNoResponse = (payload, options) => {
+		this.#SendMessageNoResponse(payload, options);
+	};
+	SendMessage = (payload, options) => {
+		return new Promise((resolve, reject) => {
+			this.#SendMessage(payload, options, (payload) => {
+				resolve(payload.responsePayload);
+			}, (payload) => {
+				reject(payload.requestPayload);
+			});
+		});
+	};
+	#SendMessageNoResponse = (payload, options) => {
+		const messageId = globalThis.crypto.randomUUID();
+		const requestPayload = {
+			header: this.#messageHeader,
+			messageId,
+			senderId: this.#id,
+			senderRole: this.#options.role,
+			requestPayload: payload,
+			responsePayload: {},
+			pid: process.pid.toString(),
+			messageType: "REQUEST_NO_RESPONSE"
+		};
+		this.#options.messageSender(requestPayload, options);
+	};
+	#SendMessage = (payload, options, callBack, errorCallBack) => {
+		const messageId = globalThis.crypto.randomUUID();
+		const requestPayload = {
+			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: {},
+			startTime: performance.now(),
+			endTime: 0,
+			timeout: setTimeout(() => {
+				setTimeout(() => {
+					delete this.#inflightMessages[messageRecord.messageId];
+				}, 0).unref();
+				errorCallBack(requestPayload);
+			}, this.#options.requestResponseMessageTimeout).unref(),
+			callBack,
+			errorCallBack
+		};
+		this.#inflightMessages[messageRecord.messageId] = messageRecord;
+		this.#options.messageSender(requestPayload, options);
+	};
+	#ProcessMessage = async (msg, options) => {
+		if (msg.header && msg.header.localeCompare(this.#messageHeader) === 0) {
+			const message = msg;
+			if (this.#inflightMessages[message.messageId]) {
+				const inFlightMessageRecord = this.#inflightMessages[message.messageId];
+				inFlightMessageRecord.responses[message.senderId] = { ...message };
+				let completed = true;
+				if (this.#options.ProcessResponseMessage) {
+					completed = await this.#options.ProcessResponseMessage(inFlightMessageRecord.responses, options);
+					if (completed) {
+						inFlightMessageRecord.endTime = performance.now();
+						clearTimeout(inFlightMessageRecord.timeout);
+						inFlightMessageRecord.callBack({ responsePayload: Object.values(inFlightMessageRecord.responses).map((r) => r.responsePayload) }, options);
+						delete this.#inflightMessages[message.messageId];
+					}
+				} else if (completed) {
+					inFlightMessageRecord.endTime = performance.now();
+					clearTimeout(inFlightMessageRecord.timeout);
+					inFlightMessageRecord.callBack(message, options);
+					delete this.#inflightMessages[message.messageId];
+				}
+			}
+		}
+	};
+	Start = (options) => {
+		this.#messageHeader = `__STS__${this.#options.namespace}__${globalThis.crypto.randomUUID()}`;
+		this.#options.messageReceiverStart(options);
+	};
+	Stop = (options) => {
+		this.#options.messageReceiverStop(options);
+		for (const [, iPCMessageProcessorWorkerRecord] of Object.entries(this.#inflightMessages)) if (iPCMessageProcessorWorkerRecord.timeout) clearTimeout(iPCMessageProcessorWorkerRecord.timeout);
+		this.#inflightMessages = {};
+	};
+	ProcessMessage = async (msg, options) => {
+		if (msg.header) {
+			const checkName = `__STS__${this.#options.namespace}__`;
+			if (msg.header.includes(checkName)) {
+				const message = msg;
+				if (msg.messageType.localeCompare("REQUEST") === 0 || msg.messageType.localeCompare("REQUEST_NO_RESPONSE") === 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) if (msg.messageType.localeCompare("REQUEST_NO_RESPONSE") === 0) this.#options.ProcessRequestMessage(message, options);
+					else {
+						message.responsePayload = await this.#options.ProcessRequestMessage(message, options);
+						message.senderId = this.#id;
+						message.messageType = "RESPONSE";
+						this.#options.messageSender(message, options);
+					}
+				} else this.#ProcessMessage(msg, options);
+			}
+		}
+	};
+};
+//#endregion
+//#region src/redisMessageHandler.ts
+var REQUEST_CHANNEL = "__STS__SVC_stsappframework_request";
+var RESPONSE_CHANNEL = "__STS__SVC_stsappframework_response";
+var RedisMessageHandler = class extends TinyEmitter {
+	#messagingManager = null;
+	#options;
+	#events = {};
+	#requestChannel;
+	#responseChannel;
+	#ioredisSubscriber;
+	#ioredisPublisher;
+	#clients = {};
+	#pingTimeout = null;
+	constructor(options) {
+		super();
+		this.#options = options;
+		this.#requestChannel = REQUEST_CHANNEL;
+		this.#responseChannel = RESPONSE_CHANNEL;
+		const redisOptions = {
+			showFriendlyErrorStack: true,
+			maxRetriesPerRequest: 20
+		};
+		this.#ioredisSubscriber = new Redis(this.#options.redisUrl, redisOptions);
+		this.#ioredisPublisher = new Redis(this.#options.redisUrl, redisOptions);
+		this.#ioredisSubscriber.on("error", (error) => {
+			this.#LogError(chalk.red(`RedisMessageHandler:constructor(): PID: [${process.pid}] Role: [${this.#options.role}] Error (redisSubscriber on error): [${error}]`));
+		});
+		this.#ioredisPublisher.on("error", (error) => {
+			this.#LogError(chalk.red(`RedisMessageHandler:constructor(): PID: [${process.pid}] Role: [${this.#options.role}] Error (redisPublisher on error): [${error}]`));
+		});
+		this.#ioredisSubscriber.subscribe(this.#requestChannel, this.#responseChannel, (error, count) => {
+			if (error) this.#LogError(chalk.red(`RedisMessageHandler:constructor(): PID: [${process.pid}] Role: [${this.#options.role}] Error - Failed to subscribe: [${error}]`));
+			else this.#LogInfo(chalk.white(`RedisMessageHandler:constructor(): PID: [${process.pid}] Role: [${this.#options.role}] Subscribed successfully! This client is currently subscribed to ${count} channels.`));
+		});
+		this.SetupPrimary();
+		if (this.#options.role.localeCompare("CLIENT") === 0) {
+			const ping = () => {
+				this.#pingTimeout = setTimeout(() => {
+					const pingData = {
+						id: this.#messagingManager.id,
+						groups: this.#options.groups
+					};
+					if (this.#options.extraData) pingData.extraData = this.#options.extraData;
+					this.emitNoResponse("ping", pingData);
+					ping();
+				}, 1e3).unref();
+			};
+			ping();
+		} else this.on("ping", (pingData, callback) => {
+			const { id, groups, extraData } = pingData;
+			if (this.#clients[id]) {
+				clearTimeout(this.#clients[id].timeout);
+				this.#clients[id].pingCount++;
+				this.#clients[id].timeout = setTimeout(() => {
+					delete this.#clients[id];
+				}, 2e3);
+				this.#clients[id].groups = groups;
+				this.#clients[id].extraData = extraData;
+			} else this.#clients[id] = {
+				id,
+				clientConnected: /* @__PURE__ */ new Date(),
+				pingCount: 0,
+				timeout: setTimeout(() => {
+					delete this.#clients[id];
+				}, 2e3),
+				groups,
+				extraData
+			};
+		});
+	}
+	#LogInfo(message) {
+		this.#options.logger.info(message);
+	}
+	#LogError(message) {
+		this.#options.logger.error(message);
+	}
+	#processRawMessage = (channel, rawmessage) => {
+		const message = JSON.parse(rawmessage);
+		this.#messagingManager?.ProcessMessage(message, { channel });
+	};
+	get clients() {
+		return this.#clients;
+	}
+	get groups() {
+		return this.#options.groups;
+	}
+	AddGroup = (group) => {
+		if (this.#options.groups.indexOf(group) === -1) this.#options.groups.push(group);
+	};
+	RemoveGroup = (group) => {
+		const removeIndex = this.#options.groups.indexOf(group);
+		if (removeIndex !== -1) this.#options.groups.splice(removeIndex, 1);
+	};
+	SetupPrimary = () => {
+		this.#messagingManager = new MessagingManager({
+			logger: this.#options.logger,
+			requestResponseMessageTimeout: 5e3,
+			namespace: this.#options.namespace,
+			role: this.#options.role,
+			groups: this.#options.groups,
+			messageSender: this.#messageSender,
+			ProcessResponseMessage: this.#ProcessResponseMessage,
+			ProcessRequestMessage: this.#processPayload,
+			messageReceiverStart: (options) => {
+				this.#ioredisSubscriber.on("message", this.#processRawMessage);
+			},
+			messageReceiverStop: (options) => {
+				this.#ioredisSubscriber.off("message", this.#processRawMessage);
+			}
+		});
+	};
+	#messageSender = (payload, options) => {
+		if (payload.messageType.localeCompare("REQUEST") === 0 || payload.messageType.localeCompare("REQUEST_NO_RESPONSE") === 0) this.#ioredisPublisher.publish(this.#requestChannel, JSON.stringify(payload));
+		else if (payload.messageType.localeCompare("RESPONSE") === 0) this.#ioredisPublisher.publish(this.#responseChannel, JSON.stringify(payload));
+	};
+	#ProcessResponseMessage = async (responses, options) => {
+		let found = true;
+		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;
+			});
+			found = true;
+			clientsInGroup.forEach((c) => {
+				if (!responses[c.id]) found = false;
+			});
+		} else {
+			const clientsInGroup = Object.values(this.#clients);
+			found = true;
+			clientsInGroup.forEach((c) => {
+				if (!responses[c.id]) found = false;
+			});
+		}
+		return found;
+	};
+	#processPayload = (payload, options) => {
+		return new Promise((resolve, reject) => {
+			if (payload.messageType.localeCompare("REQUEST") === 0 || payload.messageType.localeCompare("REQUEST_NO_RESPONSE") === 0) {
+				if (payload.requestPayload["__eventName"]) {
+					const eventName = payload.requestPayload["__eventName"];
+					if (this.#events[eventName]) try {
+						if (payload.messageType.localeCompare("REQUEST_NO_RESPONSE") === 0) {
+							this.#events[eventName].callback(...payload.requestPayload.args);
+							resolve({});
+						} else this.#events[eventName].callback(...payload.requestPayload.args, (responseMessage) => {
+							resolve(responseMessage);
+						});
+					} catch (error) {
+						reject(error);
+					}
+				}
+			}
+		});
+	};
+	on(event, callback, ctx) {
+		if (this.#events[event]) delete this.#events[event];
+		const eventObject = {
+			event,
+			callback,
+			ctx
+		};
+		this.#events[eventObject.event] = eventObject;
+		return this;
+	}
+	off(event, callback) {
+		if (this.#events[event]) delete this.#events[event];
+		return this;
+	}
+	Start = () => {
+		this.#messagingManager?.Start();
+	};
+	Stop = () => {
+		if (this.#pingTimeout) {
+			clearTimeout(this.#pingTimeout);
+			this.#pingTimeout = null;
+		}
+		this.#messagingManager?.Stop();
+		this.#ioredisSubscriber.quit();
+		this.#ioredisSubscriber.disconnect();
+		this.#ioredisPublisher.quit();
+		this.#ioredisPublisher.disconnect();
+	};
+	emit(event, ...args) {
+		(async () => {
+			try {
+				const retVal = await this.#messagingManager?.SendMessage({
+					__eventName: event,
+					args: args.slice(0, args.length - 1)
+				});
+				args[args.length - 1](retVal);
+			} catch (error) {
+				if (this.#options.ignoreEvents) {
+					if (this.#options.ignoreEvents.indexOf(error.__eventName) !== -1) return;
+				}
+				this.#options.logger.error(chalk.red(`RedisMessageHandler:emit(): Error: [${JSON.stringify(error)}]`));
+			}
+		})();
+		return this;
+	}
+	emitWithError(event, args, responseCb, errorCb) {
+		(async () => {
+			try {
+				responseCb(await this.#messagingManager?.SendMessage({
+					__eventName: event,
+					args: [args]
+				}));
+			} catch (error) {
+				if (this.#options.ignoreEvents) {
+					if (this.#options.ignoreEvents.indexOf(error.__eventName) !== -1) return;
+				}
+				errorCb(error);
+			}
+		})();
+		return this;
+	}
+	emitex = async (event, ...args) => {
+		return this.#messagingManager.SendMessage({
+			__eventName: event,
+			args
+		});
+	};
+	emitNoResponse = async (event, ...args) => {
+		this.#messagingManager.SendMessageNoResponse({
+			__eventName: event,
+			args
+		});
+	};
+};
+//#endregion
+//#region src/ipcMessageHandler.ts
+/**
+* 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 both tghe cluster primary and the cluster worker.
+* Note: Currently groups handling is not supported. Use the redis version for this capability.
+*/
+var IPCMessageHandler = class extends TinyEmitter {
+	#messagingManager = null;
+	#options;
+	#clients = {};
+	#events = {};
+	#startWorkerOptions;
+	constructor(options) {
+		super();
+		this.#options = options;
+		if (options.role.localeCompare("CLIENT") === 0) this.SetupWorker();
+		else this.SetupPrimary();
+	}
+	get __events() {
+		return this.#events;
+	}
+	AddClient = (client) => {
+		const id = globalThis.crypto.randomUUID();
+		const processMessage = (payload) => {
+			this.#messagingManager?.ProcessMessage(payload, { client });
+		};
+		client.on("message", processMessage);
+		this.#clients[id] = {
+			client,
+			processMessage
+		};
+		return id;
+	};
+	RemoveClient = (id) => {
+		const clientRecord = this.#clients[id];
+		if (clientRecord) {
+			clientRecord.client.off("message", clientRecord.processMessage);
+			delete this.#clients[id];
+		}
+	};
+	get clients() {
+		return this.#clients;
+	}
+	SetupPrimary = () => {
+		this.#messagingManager = new MessagingManager({
+			logger: defaultLogger,
+			requestResponseMessageTimeout: 5e3,
+			namespace: this.#options.namespace,
+			role: "SERVER",
+			messageSender: (payload, options) => {
+				options.client.send(payload);
+			},
+			ProcessRequestMessage: async (payload, options) => {
+				return this.#processPayload(payload, options);
+			},
+			messageReceiverStart: (options) => {},
+			messageReceiverStop: (options) => {},
+			groups: []
+		});
+	};
+	#ProcessWorkerMessageRaw = (payload) => {
+		this.#messagingManager?.ProcessMessage(payload, this.#startWorkerOptions);
+	};
+	SetupWorker = () => {
+		this.#messagingManager = new MessagingManager({
+			logger: defaultLogger,
+			requestResponseMessageTimeout: this.#options.requestResponseMessageTimeout,
+			namespace: this.#options.namespace,
+			role: "CLIENT",
+			messageSender: (payload, options) => {
+				process.send(payload);
+			},
+			ProcessRequestMessage: async (payload, options) => {
+				return this.#processPayload(payload, options);
+			},
+			messageReceiverStart: (options) => {
+				this.#startWorkerOptions = { ...options };
+				process.on("message", this.#ProcessWorkerMessageRaw);
+			},
+			messageReceiverStop: (options) => {
+				process.off("message", this.#ProcessWorkerMessageRaw);
+			},
+			groups: []
+		});
+	};
+	SendMessage = async (payload) => {
+		if (this.#messagingManager) if (this.#options.role.localeCompare("CLIENT") === 0) return this.#messagingManager?.SendMessage(payload, {});
+		else {
+			const promArray = [];
+			for (const [clientId, clientRecord] of Object.entries(this.#clients)) promArray.push(this.#messagingManager?.SendMessage(payload, { client: clientRecord.client }));
+			try {
+				return { result: await Promise.all(promArray) };
+			} catch (error) {
+				return {};
+			}
+		}
+		else return {};
+	};
+	#processPayload = (payload, options) => {
+		return new Promise((resolve, reject) => {
+			if (payload.messageType.localeCompare("REQUEST") === 0 || payload.messageType.localeCompare("REQUEST_NO_RESPONSE") === 0) {
+				if (payload.requestPayload["__eventName"]) {
+					const eventName = payload.requestPayload["__eventName"];
+					if (this.#events[eventName]) try {
+						if (payload.messageType.localeCompare("REQUEST_NO_RESPONSE") === 0) {
+							this.#events[eventName].callback(...payload.requestPayload.args);
+							resolve({});
+						} else this.#events[eventName].callback(...payload.requestPayload.args, (responseMessage) => {
+							resolve(responseMessage);
+						});
+					} catch (error) {
+						reject(error);
+					}
+				}
+			}
+		});
+	};
+	on(event, callback, ctx) {
+		if (this.#events[event]) delete this.#events[event];
+		const eventObject = {
+			event,
+			callback,
+			ctx
+		};
+		this.#events[eventObject.event] = eventObject;
+		return this;
+	}
+	off(event, callback) {
+		if (this.#events[event]) delete this.#events[event];
+		return this;
+	}
+	Start = () => {
+		this.#messagingManager?.Start({});
+	};
+	Stop = () => {
+		this.#messagingManager?.Stop({});
+	};
+	emit(event, ...args) {
+		(async () => {
+			try {
+				const retVal = await this.SendMessage({
+					__eventName: event,
+					args: args.slice(0, args.length - 1)
+				});
+				args[args.length - 1](retVal);
+			} catch (error) {
+				if (this.#options.ignoreEvents) {
+					if (this.#options.ignoreEvents.indexOf(error.__eventName) !== -1) return;
+				}
+				console.log(error);
+				this.#options.logger.error(chalk.red(`IPCMessageHandler:emit(): Error: [${JSON.stringify(error)}]`));
+			}
+		})();
+		return this;
+	}
+	emitNoResponse = async (event, ...args) => {
+		if (this.#options.role.localeCompare("CLIENT") === 0) this.#messagingManager.SendMessageNoResponse({
+			__eventName: event,
+			args
+		});
+		else for (const [clientId, clientRecord] of Object.entries(this.#clients)) this.#messagingManager.SendMessageNoResponse({
+			__eventName: event,
+			args
+		}, { client: clientRecord.client });
+	};
+};
+//#endregion
+//#region src/ipcMessageHandlerPair.ts
+/**
+* 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 both tghe cluster primary and the cluster worker.
+* Note: Currently groups handling is not supported. Use the redis version for this capability.
+*/
+var IPCMessageHandlerPair = class extends TinyEmitter {
+	#messagingManager = null;
+	#options;
+	#worker = null;
+	#events = {};
+	#startWorkerOptions;
+	#startPrimaryWorker = null;
+	constructor(options) {
+		super();
+		this.#options = options;
+		if (options.role.localeCompare("CLIENT") === 0) this.SetupWorker();
+		else this.SetupPrimary();
+	}
+	get __events() {
+		return this.#events;
+	}
+	#ProcessPrimaryMessageRaw = (payload) => {
+		this.#messagingManager?.ProcessMessage(payload, { worker: this.#startPrimaryWorker });
+	};
+	SetupPrimary = () => {
+		this.#messagingManager = new MessagingManager({
+			logger: defaultLogger,
+			requestResponseMessageTimeout: 5e3,
+			namespace: this.#options.namespace,
+			role: "SERVER",
+			messageSender: (payload, options) => {
+				options.worker.send(payload);
+			},
+			ProcessRequestMessage: async (payload, options) => {
+				return this.#processPayload(payload, options);
+			},
+			messageReceiverStart: (options) => {
+				const worker = options.worker;
+				this.#startPrimaryWorker = worker;
+				worker.on("message", this.#ProcessPrimaryMessageRaw);
+			},
+			messageReceiverStop: (options) => {
+				options.worker.off("message", this.#ProcessPrimaryMessageRaw);
+			},
+			groups: []
+		});
+	};
+	#ProcessWorkerMessageRaw = (payload) => {
+		this.#messagingManager?.ProcessMessage(payload, this.#startWorkerOptions);
+	};
+	SetupWorker = () => {
+		this.#messagingManager = new MessagingManager({
+			logger: defaultLogger,
+			requestResponseMessageTimeout: this.#options.requestResponseMessageTimeout,
+			namespace: this.#options.namespace,
+			role: "CLIENT",
+			messageSender: (payload, options) => {
+				process.send(payload);
+			},
+			ProcessRequestMessage: async (payload, options) => {
+				return this.#processPayload(payload, options);
+			},
+			messageReceiverStart: (options) => {
+				this.#startWorkerOptions = { ...options };
+				process.on("message", this.#ProcessWorkerMessageRaw);
+			},
+			messageReceiverStop: (options) => {
+				process.off("message", this.#ProcessWorkerMessageRaw);
+			},
+			groups: []
+		});
+	};
+	SendMessage = async (payload) => {
+		if (this.#messagingManager) if (this.#worker) return this.#messagingManager?.SendMessage(payload, { worker: this.#worker });
+		else return this.#messagingManager?.SendMessage(payload, {});
+		else return {};
+	};
+	#processPayload = (payload, options) => {
+		return new Promise((resolve, reject) => {
+			if (payload.messageType.localeCompare("REQUEST") === 0 || payload.messageType.localeCompare("REQUEST_NO_RESPONSE") === 0) {
+				if (payload.requestPayload["__eventName"]) {
+					const eventName = payload.requestPayload["__eventName"];
+					if (this.#events[eventName]) try {
+						if (payload.messageType.localeCompare("REQUEST_NO_RESPONSE") === 0) {
+							this.#events[eventName].callback(...payload.requestPayload.args);
+							resolve({});
+						} else this.#events[eventName].callback(...payload.requestPayload.args, (responseMessage) => {
+							resolve(responseMessage);
+						});
+					} catch (error) {
+						reject(error);
+					}
+				}
+			}
+		});
+	};
+	on(event, callback, ctx) {
+		if (this.#events[event]) delete this.#events[event];
+		const eventObject = {
+			event,
+			callback,
+			ctx
+		};
+		this.#events[eventObject.event] = eventObject;
+		return this;
+	}
+	off(event, callback) {
+		if (this.#events[event]) delete this.#events[event];
+		return this;
+	}
+	Start = (worker) => {
+		if (worker) {
+			this.#messagingManager?.Start({ worker });
+			this.#worker = worker;
+		} else this.#messagingManager?.Start({});
+	};
+	Stop = () => {
+		if (this.#worker) {
+			this.#messagingManager?.Stop({ worker: this.#worker });
+			this.#worker = null;
+		} else this.#messagingManager?.Stop({});
+	};
+	get worker() {
+		return this.#worker;
+	}
+	emit(event, ...args) {
+		(async () => {
+			try {
+				const retVal = await this.SendMessage({
+					__eventName: event,
+					args: args.slice(0, args.length - 1)
+				});
+				args[args.length - 1](retVal);
+			} catch (error) {
+				if (this.#options.ignoreEvents) {
+					if (this.#options.ignoreEvents.indexOf(error.__eventName) !== -1) return;
+				}
+				console.log(error);
+				this.#options.logger.error(chalk.red(`IPCMessageHandler:emit(): Error: [${JSON.stringify(error)}]`));
+			}
+		})();
+		return this;
+	}
+	emitNoResponse = async (event, ...args) => {
+		this.#messagingManager.SendMessageNoResponse({
+			__eventName: event,
+			args
+		});
+	};
+};
+//#endregion
+export { IPCMessageHandler, IPCMessageHandlerPair, MessagingManager, RedisMessageHandler };
+
+//# sourceMappingURL=index.mjs.map