@nsshunt/stsmessaging 1.0.6

package/dist/stsmessaging.mjs

@@ -0,0 +1,892 @@
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _id, _options, _inflightMessages, _messageHeader, _SendMessageNoResponse, _SendMessage, _ProcessMessage, _messagingManager, _options2, _events, _requestChannel, _responseChannel, _redisSubscriber, _redisPublisher, _clients, _pingTimeout, _RedisMessageHandler_instances, LogInfo_fn, LogError_fn, _processRawMessage, _messageSender, _ProcessResponseMessage, _processPayload, _messagingManager2, _options3, _clients2, _events2, _startWorkerOptions, _ProcessWorkerMessageRaw, _processPayload2, _messagingManager3, _options4, _worker, _events3, _startWorkerOptions2, _startPrimaryWorker, _ProcessPrimaryMessageRaw, _ProcessWorkerMessageRaw2, _processPayload3;
+import { v4 } from "uuid";
+import { TinyEmitter } from "tiny-emitter";
+import { Redis } from "ioredis";
+import chalk from "chalk";
+import { defaultLogger } from "@nsshunt/stsutils";
+class MessagingManager {
+  constructor(options) {
+    __privateAdd(this, _id);
+    __privateAdd(this, _options);
+    __privateAdd(this, _inflightMessages, {});
+    __privateAdd(this, _messageHeader);
+    __publicField(this, "SendMessageNoResponse", (payload, options) => {
+      __privateGet(this, _SendMessageNoResponse).call(this, payload, options);
+    });
+    __publicField(this, "SendMessage", (payload, options) => {
+      return new Promise((resolve, reject) => {
+        __privateGet(this, _SendMessage).call(this, payload, options, (payload2) => {
+          resolve(payload2.responsePayload);
+        }, (payload2) => {
+          reject(payload2.requestPayload);
+        });
+      });
+    });
+    __privateAdd(this, _SendMessageNoResponse, (payload, options) => {
+      const messageId = v4();
+      const requestPayload = {
+        header: __privateGet(this, _messageHeader),
+        messageId,
+        senderId: __privateGet(this, _id),
+        senderRole: __privateGet(this, _options).role,
+        requestPayload: payload,
+        responsePayload: {},
+        pid: process.pid.toString(),
+        messageType: "REQUEST_NO_RESPONSE"
+      };
+      __privateGet(this, _options).messageSender(requestPayload, options);
+    });
+    __privateAdd(this, _SendMessage, (payload, options, callBack, errorCallBack) => {
+      const messageId = v4();
+      const requestPayload = {
+        header: __privateGet(this, _messageHeader),
+        messageId,
+        senderId: __privateGet(this, _id),
+        senderRole: __privateGet(this, _options).role,
+        requestPayload: payload,
+        responsePayload: {},
+        pid: process.pid.toString(),
+        messageType: "REQUEST"
+      };
+      const messageRecord = {
+        messageId,
+        senderId: __privateGet(this, _id),
+        senderRole: __privateGet(this, _options).role,
+        requestPayload,
+        responses: {},
+        // record
+        startTime: performance.now(),
+        endTime: 0,
+        timeout: setTimeout(() => {
+          setTimeout(() => {
+            delete __privateGet(this, _inflightMessages)[messageRecord.messageId];
+          }, 0).unref();
+          errorCallBack(requestPayload);
+        }, __privateGet(this, _options).requestResponseMessageTimeout).unref(),
+        // max message timeout allowed
+        callBack,
+        errorCallBack
+      };
+      __privateGet(this, _inflightMessages)[messageRecord.messageId] = messageRecord;
+      __privateGet(this, _options).messageSender(requestPayload, options);
+    });
+    __privateAdd(this, _ProcessMessage, async (msg, options) => {
+      if (msg.header && msg.header.localeCompare(__privateGet(this, _messageHeader)) === 0) {
+        const message = msg;
+        if (__privateGet(this, _inflightMessages)[message.messageId]) {
+          const inFlightMessageRecord = __privateGet(this, _inflightMessages)[message.messageId];
+          inFlightMessageRecord.responses[message.senderId] = { ...message };
+          let completed = true;
+          if (__privateGet(this, _options).ProcessResponseMessage) {
+            completed = await __privateGet(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 __privateGet(this, _inflightMessages)[message.messageId];
+            }
+          } else if (completed) {
+            inFlightMessageRecord.endTime = performance.now();
+            clearTimeout(inFlightMessageRecord.timeout);
+            inFlightMessageRecord.callBack(message, options);
+            delete __privateGet(this, _inflightMessages)[message.messageId];
+          } else ;
+        }
+      }
+    });
+    __publicField(this, "Start", (options) => {
+      __privateSet(this, _messageHeader, `__STS__${__privateGet(this, _options).namespace}__${v4()}`);
+      __privateGet(this, _options).messageReceiverStart(options);
+    });
+    __publicField(this, "Stop", (options) => {
+      __privateGet(this, _options).messageReceiverStop(options);
+      for (const [, iPCMessageProcessorWorkerRecord] of Object.entries(__privateGet(this, _inflightMessages))) {
+        if (iPCMessageProcessorWorkerRecord.timeout) {
+          clearTimeout(iPCMessageProcessorWorkerRecord.timeout);
+        }
+      }
+      __privateSet(this, _inflightMessages, {});
+    });
+    // Process a message recieved from a worker
+    __publicField(this, "ProcessMessage", async (msg, options) => {
+      if (msg.header) {
+        const checkName = `__STS__${__privateGet(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 = __privateGet(this, _options).groups.indexOf(group) === -1 ? false : true;
+            }
+            if (processMessage) {
+              if (msg.messageType.localeCompare("REQUEST_NO_RESPONSE") === 0) {
+                __privateGet(this, _options).ProcessRequestMessage(message, options);
+              } else {
+                message.responsePayload = await __privateGet(this, _options).ProcessRequestMessage(message, options);
+                message.senderId = __privateGet(this, _id);
+                message.messageType = "RESPONSE";
+                __privateGet(this, _options).messageSender(message, options);
+              }
+            }
+          } else {
+            __privateGet(this, _ProcessMessage).call(this, msg, options);
+          }
+        }
+      }
+    });
+    __privateSet(this, _id, v4());
+    __privateSet(this, _options, options);
+    __privateSet(this, _messageHeader, `__STS__${__privateGet(this, _options).namespace}__${v4()}`);
+  }
+  get id() {
+    return __privateGet(this, _id);
+  }
+  // eslint-disable-next-line  @typescript-eslint/no-unused-vars
+  ReceivedMessageFromMaster(msg) {
+  }
+}
+_id = new WeakMap();
+_options = new WeakMap();
+_inflightMessages = new WeakMap();
+_messageHeader = new WeakMap();
+_SendMessageNoResponse = new WeakMap();
+_SendMessage = new WeakMap();
+_ProcessMessage = new WeakMap();
+const REQUEST_CHANNEL = "__STS__SVC_stsappframework_request";
+const RESPONSE_CHANNEL = "__STS__SVC_stsappframework_response";
+class RedisMessageHandler extends TinyEmitter {
+  constructor(options) {
+    super();
+    __privateAdd(this, _RedisMessageHandler_instances);
+    __privateAdd(this, _messagingManager, null);
+    __privateAdd(this, _options2);
+    __privateAdd(this, _events, {});
+    __privateAdd(this, _requestChannel);
+    __privateAdd(this, _responseChannel);
+    __privateAdd(this, _redisSubscriber);
+    __privateAdd(this, _redisPublisher);
+    __privateAdd(this, _clients, {});
+    __privateAdd(this, _pingTimeout, null);
+    __privateAdd(this, _processRawMessage, (channel, rawmessage) => {
+      var _a;
+      const message = JSON.parse(rawmessage);
+      (_a = __privateGet(this, _messagingManager)) == null ? void 0 : _a.ProcessMessage(message, { channel });
+    });
+    __publicField(this, "AddGroup", (group) => {
+      const index = __privateGet(this, _options2).groups.indexOf(group);
+      if (index === -1) {
+        __privateGet(this, _options2).groups.push(group);
+      }
+    });
+    __publicField(this, "RemoveGroup", (group) => {
+      const removeIndex = __privateGet(this, _options2).groups.indexOf(group);
+      if (removeIndex !== -1) {
+        __privateGet(this, _options2).groups.splice(removeIndex, 1);
+      }
+    });
+    __publicField(this, "SetupPrimary", () => {
+      const ipcMessageManagerOptions = {
+        logger: __privateGet(this, _options2).logger,
+        requestResponseMessageTimeout: 5e3,
+        namespace: __privateGet(this, _options2).namespace,
+        role: __privateGet(this, _options2).role,
+        groups: __privateGet(this, _options2).groups,
+        messageSender: __privateGet(this, _messageSender),
+        // This method is used to calculate if all responses have been received from multiple clients (broadcast)
+        // returns true/false.
+        ProcessResponseMessage: __privateGet(this, _ProcessResponseMessage),
+        // This gets called when an event is received from a message receiver (when ProcessMessage is invoked from the receiver event handler)
+        ProcessRequestMessage: __privateGet(this, _processPayload),
+        messageReceiverStart: (options) => {
+          __privateGet(this, _redisSubscriber).on("message", __privateGet(this, _processRawMessage));
+        },
+        messageReceiverStop: (options) => {
+          __privateGet(this, _redisSubscriber).off("message", __privateGet(this, _processRawMessage));
+        }
+      };
+      __privateSet(this, _messagingManager, new MessagingManager(ipcMessageManagerOptions));
+    });
+    __privateAdd(this, _messageSender, (payload, options) => {
+      if (payload.messageType.localeCompare("REQUEST") === 0 || payload.messageType.localeCompare("REQUEST_NO_RESPONSE") === 0) {
+        __privateGet(this, _redisPublisher).publish(__privateGet(this, _requestChannel), JSON.stringify(payload));
+      } else if (payload.messageType.localeCompare("RESPONSE") === 0) {
+        __privateGet(this, _redisPublisher).publish(__privateGet(this, _responseChannel), JSON.stringify(payload));
+      }
+    });
+    __privateAdd(this, _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(__privateGet(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(__privateGet(this, _clients));
+        found = true;
+        clientsInGroup.forEach((c) => {
+          if (!responses[c.id]) {
+            found = false;
+          }
+        });
+      }
+      return found;
+    });
+    __privateAdd(this, _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 (__privateGet(this, _events)[eventName]) {
+              try {
+                if (payload.messageType.localeCompare("REQUEST_NO_RESPONSE") === 0) {
+                  __privateGet(this, _events)[eventName].callback(...payload.requestPayload.args);
+                  resolve({});
+                } else {
+                  __privateGet(this, _events)[eventName].callback(...payload.requestPayload.args, (responseMessage) => {
+                    resolve(responseMessage);
+                  });
+                }
+              } catch (error) {
+                reject(error);
+              }
+            }
+          }
+        }
+      });
+    });
+    __publicField(this, "Start", () => {
+      var _a;
+      (_a = __privateGet(this, _messagingManager)) == null ? void 0 : _a.Start();
+    });
+    __publicField(this, "Stop", () => {
+      var _a;
+      if (__privateGet(this, _pingTimeout)) {
+        clearTimeout(__privateGet(this, _pingTimeout));
+        __privateSet(this, _pingTimeout, null);
+      }
+      (_a = __privateGet(this, _messagingManager)) == null ? void 0 : _a.Stop();
+      __privateGet(this, _redisSubscriber).quit();
+      __privateGet(this, _redisSubscriber).disconnect();
+      __privateGet(this, _redisPublisher).quit();
+      __privateGet(this, _redisPublisher).disconnect();
+    });
+    __publicField(this, "emitex", async (event, ...args) => {
+      return __privateGet(this, _messagingManager).SendMessage({
+        __eventName: event,
+        args
+      });
+    });
+    __publicField(this, "emitNoResponse", async (event, ...args) => {
+      __privateGet(this, _messagingManager).SendMessageNoResponse({
+        __eventName: event,
+        args
+      });
+    });
+    __privateSet(this, _options2, options);
+    __privateSet(this, _requestChannel, REQUEST_CHANNEL);
+    __privateSet(this, _responseChannel, RESPONSE_CHANNEL);
+    const redisOptions = {
+      showFriendlyErrorStack: true,
+      maxRetriesPerRequest: 20
+    };
+    __privateSet(this, _redisSubscriber, new Redis(__privateGet(this, _options2).redisUrl, redisOptions));
+    __privateSet(this, _redisPublisher, new Redis(__privateGet(this, _options2).redisUrl, redisOptions));
+    __privateGet(this, _redisSubscriber).subscribe(__privateGet(this, _requestChannel), __privateGet(this, _responseChannel), (error, count) => {
+      if (error) {
+        __privateMethod(this, _RedisMessageHandler_instances, LogError_fn).call(this, chalk.red(`RedisAdminManager:constructor(): PID: [${process.pid}] Role: [${__privateGet(this, _options2).role}] Error - Failed to subscribe: [${error}]`));
+      } else {
+        __privateMethod(this, _RedisMessageHandler_instances, LogInfo_fn).call(this, chalk.white(`RedisAdminManager:constructor(): PID: [${process.pid}] Role: [${__privateGet(this, _options2).role}] Subscribed successfully! This client is currently subscribed to ${count} channels.`));
+      }
+    });
+    this.SetupPrimary();
+    if (__privateGet(this, _options2).role.localeCompare("CLIENT") === 0) {
+      const ping = () => {
+        __privateSet(this, _pingTimeout, setTimeout(() => {
+          const pingData = {
+            id: __privateGet(this, _messagingManager).id,
+            groups: __privateGet(this, _options2).groups
+          };
+          if (__privateGet(this, _options2).extraData) {
+            pingData.extraData = __privateGet(this, _options2).extraData;
+          }
+          this.emitNoResponse("ping", pingData);
+          ping();
+        }, 1e3).unref());
+      };
+      ping();
+    } else {
+      this.on("ping", (pingData, callback) => {
+        const { id, groups, extraData } = pingData;
+        if (__privateGet(this, _clients)[id]) {
+          clearTimeout(__privateGet(this, _clients)[id].timeout);
+          __privateGet(this, _clients)[id].pingCount++;
+          __privateGet(this, _clients)[id].timeout = setTimeout(() => {
+            delete __privateGet(this, _clients)[id];
+          }, 2e3);
+          __privateGet(this, _clients)[id].groups = groups;
+          __privateGet(this, _clients)[id].extraData = extraData;
+        } else {
+          __privateGet(this, _clients)[id] = {
+            id,
+            clientConnected: /* @__PURE__ */ new Date(),
+            pingCount: 0,
+            timeout: setTimeout(() => {
+              delete __privateGet(this, _clients)[id];
+            }, 2e3),
+            groups,
+            extraData
+          };
+        }
+      });
+    }
+  }
+  get clients() {
+    return __privateGet(this, _clients);
+  }
+  get groups() {
+    return __privateGet(this, _options2).groups;
+  }
+  // p.on('fromworker', (arg1: number, arg2: string, callback: any) => {
+  on(event, callback, ctx) {
+    if (__privateGet(this, _events)[event]) {
+      delete __privateGet(this, _events)[event];
+    }
+    const eventObject = {
+      event,
+      callback,
+      ctx
+    };
+    __privateGet(this, _events)[eventObject.event] = eventObject;
+    return this;
+  }
+  off(event, callback) {
+    if (__privateGet(this, _events)[event]) {
+      delete __privateGet(this, _events)[event];
+    }
+    return this;
+  }
+  emit(event, ...args) {
+    (async () => {
+      var _a;
+      try {
+        const retVal = await ((_a = __privateGet(this, _messagingManager)) == null ? void 0 : _a.SendMessage({
+          __eventName: event,
+          args: args.slice(0, args.length - 1)
+        }));
+        args[args.length - 1](retVal);
+      } catch (error) {
+        if (__privateGet(this, _options2).ignoreEvents) {
+          if (__privateGet(this, _options2).ignoreEvents.indexOf(error.__eventName) !== -1) {
+            return;
+          }
+        }
+        __privateGet(this, _options2).logger.error(chalk.red(`RedisMessageHandler:emit(): Error: [${JSON.stringify(error)}]`));
+      }
+    })();
+    return this;
+  }
+  emitWithError(event, args, responseCb, errorCb) {
+    (async () => {
+      var _a;
+      try {
+        const retVal = await ((_a = __privateGet(this, _messagingManager)) == null ? void 0 : _a.SendMessage({
+          __eventName: event,
+          args: [args]
+        }));
+        responseCb(retVal);
+      } catch (error) {
+        if (__privateGet(this, _options2).ignoreEvents) {
+          if (__privateGet(this, _options2).ignoreEvents.indexOf(error.__eventName) !== -1) {
+            return;
+          }
+        }
+        errorCb(error);
+      }
+    })();
+    return this;
+  }
+}
+_messagingManager = new WeakMap();
+_options2 = new WeakMap();
+_events = new WeakMap();
+_requestChannel = new WeakMap();
+_responseChannel = new WeakMap();
+_redisSubscriber = new WeakMap();
+_redisPublisher = new WeakMap();
+_clients = new WeakMap();
+_pingTimeout = new WeakMap();
+_RedisMessageHandler_instances = new WeakSet();
+LogInfo_fn = function(message) {
+  __privateGet(this, _options2).logger.info(message);
+};
+LogError_fn = function(message) {
+  __privateGet(this, _options2).logger.error(message);
+};
+_processRawMessage = new WeakMap();
+_messageSender = new WeakMap();
+_ProcessResponseMessage = new WeakMap();
+_processPayload = new WeakMap();
+class IPCMessageHandler extends TinyEmitter {
+  constructor(options) {
+    super();
+    __privateAdd(this, _messagingManager2, null);
+    __privateAdd(this, _options3);
+    __privateAdd(this, _clients2, {});
+    __privateAdd(this, _events2, {});
+    __privateAdd(this, _startWorkerOptions);
+    __publicField(this, "AddClient", (client) => {
+      const id = v4();
+      const processMessage = (payload) => {
+        var _a;
+        (_a = __privateGet(this, _messagingManager2)) == null ? void 0 : _a.ProcessMessage(payload, { client });
+      };
+      client.on("message", processMessage);
+      __privateGet(this, _clients2)[id] = {
+        client,
+        processMessage
+      };
+      return id;
+    });
+    __publicField(this, "RemoveClient", (id) => {
+      const clientRecord = __privateGet(this, _clients2)[id];
+      if (clientRecord) {
+        clientRecord.client.off("message", clientRecord.processMessage);
+        delete __privateGet(this, _clients2)[id];
+      }
+    });
+    __publicField(this, "SetupPrimary", () => {
+      const ipcMessageManagerOptions = {
+        logger: defaultLogger,
+        requestResponseMessageTimeout: 5e3,
+        namespace: __privateGet(this, _options3).namespace,
+        role: "SERVER",
+        messageSender: (payload, options) => {
+          options.client.send(payload);
+        },
+        ProcessRequestMessage: async (payload, options) => {
+          return __privateGet(this, _processPayload2).call(this, payload, options);
+        },
+        //@@ also need way to add/remove a worker/child to the collection
+        //@@ the ping should also auto remove (such as a failed worker)
+        messageReceiverStart: (options) => {
+        },
+        messageReceiverStop: (options) => {
+        },
+        groups: []
+      };
+      __privateSet(this, _messagingManager2, new MessagingManager(ipcMessageManagerOptions));
+    });
+    __privateAdd(this, _ProcessWorkerMessageRaw, (payload) => {
+      var _a;
+      (_a = __privateGet(this, _messagingManager2)) == null ? void 0 : _a.ProcessMessage(payload, __privateGet(this, _startWorkerOptions));
+    });
+    __publicField(this, "SetupWorker", () => {
+      const ipcMessageManagerOptions = {
+        logger: defaultLogger,
+        requestResponseMessageTimeout: __privateGet(this, _options3).requestResponseMessageTimeout,
+        namespace: __privateGet(this, _options3).namespace,
+        role: "CLIENT",
+        messageSender: (payload, options) => {
+          process.send(payload);
+        },
+        ProcessRequestMessage: async (payload, options) => {
+          return __privateGet(this, _processPayload2).call(this, payload, options);
+        },
+        messageReceiverStart: (options) => {
+          __privateSet(this, _startWorkerOptions, { ...options });
+          process.on("message", __privateGet(this, _ProcessWorkerMessageRaw));
+        },
+        messageReceiverStop: (options) => {
+          process.off("message", __privateGet(this, _ProcessWorkerMessageRaw));
+        },
+        groups: []
+      };
+      __privateSet(this, _messagingManager2, new MessagingManager(ipcMessageManagerOptions));
+    });
+    __publicField(this, "SendMessage", async (payload) => {
+      var _a, _b;
+      if (__privateGet(this, _messagingManager2)) {
+        if (__privateGet(this, _options3).role.localeCompare("CLIENT") === 0) {
+          return (_a = __privateGet(this, _messagingManager2)) == null ? void 0 : _a.SendMessage(payload, {});
+        } else {
+          const promArray = [];
+          for (const [clientId, clientRecord] of Object.entries(__privateGet(this, _clients2))) {
+            promArray.push((_b = __privateGet(this, _messagingManager2)) == null ? void 0 : _b.SendMessage(payload, { client: clientRecord.client }));
+          }
+          try {
+            const retVal = await Promise.all(promArray);
+            return {
+              result: retVal
+            };
+          } catch (error) {
+            return {};
+          }
+        }
+      } else {
+        return {};
+      }
+    });
+    __privateAdd(this, _processPayload2, (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 (__privateGet(this, _events2)[eventName]) {
+              try {
+                if (payload.messageType.localeCompare("REQUEST_NO_RESPONSE") === 0) {
+                  __privateGet(this, _events2)[eventName].callback(...payload.requestPayload.args);
+                  resolve({});
+                } else {
+                  __privateGet(this, _events2)[eventName].callback(...payload.requestPayload.args, (responseMessage) => {
+                    resolve(responseMessage);
+                  });
+                }
+              } catch (error) {
+                reject(error);
+              }
+            }
+          }
+        }
+      });
+    });
+    // Supply complete collection of workers
+    __publicField(this, "Start", () => {
+      var _a;
+      (_a = __privateGet(this, _messagingManager2)) == null ? void 0 : _a.Start({});
+    });
+    // Supply complete collection of workers
+    __publicField(this, "Stop", () => {
+      var _a;
+      (_a = __privateGet(this, _messagingManager2)) == null ? void 0 : _a.Stop({});
+    });
+    __publicField(this, "emitNoResponse", async (event, ...args) => {
+      if (__privateGet(this, _options3).role.localeCompare("CLIENT") === 0) {
+        __privateGet(this, _messagingManager2).SendMessageNoResponse({
+          __eventName: event,
+          args
+        });
+      } else {
+        for (const [clientId, clientRecord] of Object.entries(__privateGet(this, _clients2))) {
+          __privateGet(this, _messagingManager2).SendMessageNoResponse({
+            __eventName: event,
+            args
+          }, { client: clientRecord.client });
+        }
+      }
+    });
+    __privateSet(this, _options3, options);
+    if (options.role.localeCompare("CLIENT") === 0) {
+      this.SetupWorker();
+    } else {
+      this.SetupPrimary();
+    }
+  }
+  get __events() {
+    return __privateGet(this, _events2);
+  }
+  get clients() {
+    return __privateGet(this, _clients2);
+  }
+  // p.on('fromworker', (arg1: number, arg2: string, callback: any) => {
+  on(event, callback, ctx) {
+    if (__privateGet(this, _events2)[event]) {
+      delete __privateGet(this, _events2)[event];
+    }
+    const eventObject = {
+      event,
+      callback,
+      ctx
+    };
+    __privateGet(this, _events2)[eventObject.event] = eventObject;
+    return this;
+  }
+  off(event, callback) {
+    if (__privateGet(this, _events2)[event]) {
+      delete __privateGet(this, _events2)[event];
+    }
+    return this;
+  }
+  /*
+  override emit(event: string, ...args: any[]): this {
+      const sendMessage = async () => {
+          const retVal = await this.SendMessage({
+              __eventName: event,
+              args: args.slice(0, args.length-1)
+          });
+          // Invoke the response callback
+          args[args.length-1](retVal);
+      };
+      sendMessage();
+      return this;
+      //return super.emit(event, ...args);
+  }
+  */
+  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 (__privateGet(this, _options3).ignoreEvents) {
+          if (__privateGet(this, _options3).ignoreEvents.indexOf(error.__eventName) !== -1) {
+            return;
+          }
+        }
+        console.log(error);
+        __privateGet(this, _options3).logger.error(chalk.red(`IPCMessageHandler:emit(): Error: [${JSON.stringify(error)}]`));
+      }
+    })();
+    return this;
+  }
+}
+_messagingManager2 = new WeakMap();
+_options3 = new WeakMap();
+_clients2 = new WeakMap();
+_events2 = new WeakMap();
+_startWorkerOptions = new WeakMap();
+_ProcessWorkerMessageRaw = new WeakMap();
+_processPayload2 = new WeakMap();
+class IPCMessageHandlerPair extends TinyEmitter {
+  constructor(options) {
+    super();
+    __privateAdd(this, _messagingManager3, null);
+    __privateAdd(this, _options4);
+    __privateAdd(this, _worker, null);
+    __privateAdd(this, _events3, {});
+    __privateAdd(this, _startWorkerOptions2);
+    __privateAdd(this, _startPrimaryWorker, null);
+    __privateAdd(this, _ProcessPrimaryMessageRaw, (payload) => {
+      var _a;
+      (_a = __privateGet(this, _messagingManager3)) == null ? void 0 : _a.ProcessMessage(payload, { worker: __privateGet(this, _startPrimaryWorker) });
+    });
+    __publicField(this, "SetupPrimary", () => {
+      const ipcMessageManagerOptions = {
+        logger: defaultLogger,
+        requestResponseMessageTimeout: 5e3,
+        namespace: __privateGet(this, _options4).namespace,
+        role: "SERVER",
+        messageSender: (payload, options) => {
+          options.worker.send(payload);
+        },
+        ProcessRequestMessage: async (payload, options) => {
+          return __privateGet(this, _processPayload3).call(this, payload, options);
+        },
+        //@@ also need way to add/remove a worker/child to the collection
+        //@@ the ping should also auto remove (such as a failed worker)
+        messageReceiverStart: (options) => {
+          const worker = options.worker;
+          __privateSet(this, _startPrimaryWorker, worker);
+          worker.on("message", __privateGet(this, _ProcessPrimaryMessageRaw));
+        },
+        messageReceiverStop: (options) => {
+          const worker = options.worker;
+          worker.off("message", __privateGet(this, _ProcessPrimaryMessageRaw));
+        },
+        groups: []
+      };
+      __privateSet(this, _messagingManager3, new MessagingManager(ipcMessageManagerOptions));
+    });
+    __privateAdd(this, _ProcessWorkerMessageRaw2, (payload) => {
+      var _a;
+      (_a = __privateGet(this, _messagingManager3)) == null ? void 0 : _a.ProcessMessage(payload, __privateGet(this, _startWorkerOptions2));
+    });
+    __publicField(this, "SetupWorker", () => {
+      const ipcMessageManagerOptions = {
+        logger: defaultLogger,
+        requestResponseMessageTimeout: __privateGet(this, _options4).requestResponseMessageTimeout,
+        namespace: __privateGet(this, _options4).namespace,
+        role: "CLIENT",
+        messageSender: (payload, options) => {
+          process.send(payload);
+        },
+        ProcessRequestMessage: async (payload, options) => {
+          return __privateGet(this, _processPayload3).call(this, payload, options);
+        },
+        messageReceiverStart: (options) => {
+          __privateSet(this, _startWorkerOptions2, { ...options });
+          process.on("message", __privateGet(this, _ProcessWorkerMessageRaw2));
+        },
+        messageReceiverStop: (options) => {
+          process.off("message", __privateGet(this, _ProcessWorkerMessageRaw2));
+        },
+        groups: []
+      };
+      __privateSet(this, _messagingManager3, new MessagingManager(ipcMessageManagerOptions));
+    });
+    __publicField(this, "SendMessage", async (payload) => {
+      var _a, _b;
+      if (__privateGet(this, _messagingManager3)) {
+        if (__privateGet(this, _worker)) {
+          return (_a = __privateGet(this, _messagingManager3)) == null ? void 0 : _a.SendMessage(payload, { worker: __privateGet(this, _worker) });
+        } else {
+          return (_b = __privateGet(this, _messagingManager3)) == null ? void 0 : _b.SendMessage(payload, {});
+        }
+      } else {
+        return {};
+      }
+    });
+    __privateAdd(this, _processPayload3, (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 (__privateGet(this, _events3)[eventName]) {
+              try {
+                if (payload.messageType.localeCompare("REQUEST_NO_RESPONSE") === 0) {
+                  __privateGet(this, _events3)[eventName].callback(...payload.requestPayload.args);
+                  resolve({});
+                } else {
+                  __privateGet(this, _events3)[eventName].callback(...payload.requestPayload.args, (responseMessage) => {
+                    resolve(responseMessage);
+                  });
+                }
+              } catch (error) {
+                reject(error);
+              }
+            }
+          }
+        }
+      });
+    });
+    // Supply complete collection of workers
+    __publicField(this, "Start", (worker) => {
+      var _a, _b;
+      if (worker) {
+        (_a = __privateGet(this, _messagingManager3)) == null ? void 0 : _a.Start({ worker });
+        __privateSet(this, _worker, worker);
+      } else {
+        (_b = __privateGet(this, _messagingManager3)) == null ? void 0 : _b.Start({});
+      }
+    });
+    // Supply complete collection of workers
+    __publicField(this, "Stop", () => {
+      var _a, _b;
+      if (__privateGet(this, _worker)) {
+        (_a = __privateGet(this, _messagingManager3)) == null ? void 0 : _a.Stop({ worker: __privateGet(this, _worker) });
+        __privateSet(this, _worker, null);
+      } else {
+        (_b = __privateGet(this, _messagingManager3)) == null ? void 0 : _b.Stop({});
+      }
+    });
+    __publicField(this, "emitNoResponse", async (event, ...args) => {
+      __privateGet(this, _messagingManager3).SendMessageNoResponse({
+        __eventName: event,
+        args
+      });
+    });
+    __privateSet(this, _options4, options);
+    if (options.role.localeCompare("CLIENT") === 0) {
+      this.SetupWorker();
+    } else {
+      this.SetupPrimary();
+    }
+  }
+  get __events() {
+    return __privateGet(this, _events3);
+  }
+  // p.on('fromworker', (arg1: number, arg2: string, callback: any) => {
+  on(event, callback, ctx) {
+    if (__privateGet(this, _events3)[event]) {
+      delete __privateGet(this, _events3)[event];
+    }
+    const eventObject = {
+      event,
+      callback,
+      ctx
+    };
+    __privateGet(this, _events3)[eventObject.event] = eventObject;
+    return this;
+  }
+  off(event, callback) {
+    if (__privateGet(this, _events3)[event]) {
+      delete __privateGet(this, _events3)[event];
+    }
+    return this;
+  }
+  get worker() {
+    return __privateGet(this, _worker);
+  }
+  /*
+  override emit(event: string, ...args: any[]): this {
+      const sendMessage = async () => {
+          const retVal = await this.SendMessage({
+              __eventName: event,
+              args: args.slice(0, args.length-1)
+          });
+          // Invoke the response callback
+          args[args.length-1](retVal);
+      };
+      sendMessage();
+      return this;
+      //return super.emit(event, ...args);
+  }
+  */
+  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 (__privateGet(this, _options4).ignoreEvents) {
+          if (__privateGet(this, _options4).ignoreEvents.indexOf(error.__eventName) !== -1) {
+            return;
+          }
+        }
+        console.log(error);
+        __privateGet(this, _options4).logger.error(chalk.red(`IPCMessageHandler:emit(): Error: [${JSON.stringify(error)}]`));
+      }
+    })();
+    return this;
+  }
+}
+_messagingManager3 = new WeakMap();
+_options4 = new WeakMap();
+_worker = new WeakMap();
+_events3 = new WeakMap();
+_startWorkerOptions2 = new WeakMap();
+_startPrimaryWorker = new WeakMap();
+_ProcessPrimaryMessageRaw = new WeakMap();
+_ProcessWorkerMessageRaw2 = new WeakMap();
+_processPayload3 = new WeakMap();
+export {
+  IPCMessageHandler,
+  IPCMessageHandlerPair,
+  MessagingManager,
+  RedisMessageHandler
+};
+//# sourceMappingURL=stsmessaging.mjs.map