@nsshunt/stsutils 1.16.67 → 1.16.69

package/dist/stsutils.mjs

@@ -8,7 +8,7 @@ var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot
 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 _options;
+var _options, _id, _options2, _inflightMessages, _messageHeader, _SendMessage, _ProcessMessage, _ipcMessageManager, _options3, _events, _clients, _pingTimeout, _messagePort, _processRawMessage, _messageSender, _ProcessResponseMessage, _processPayload;
 import Ajv from "ajv/dist/jtd.js";
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
@@ -1437,6 +1437,52 @@ chalk.stderr = Chalk({ level: stderrColor ? stderrColor.level : 0 });
 chalk.stderr.supportsColor = stderrColor;
 var source = chalk;
 const chalk$1 = /* @__PURE__ */ getDefaultExportFromCjs(source);
+var ModelDelimeter = /* @__PURE__ */ ((ModelDelimeter2) => {
+  ModelDelimeter2["ROOT"] = "_";
+  ModelDelimeter2["SEPERATOR"] = "|";
+  ModelDelimeter2["COMPONENT_SEPERATOR"] = "@";
+  ModelDelimeter2["NID_SEPERATOR"] = "^";
+  return ModelDelimeter2;
+})(ModelDelimeter || {});
+const CheckValidChar = (checkParams) => {
+  const invalidChars = [
+    "_",
+    "|",
+    "@",
+    "^"
+    /* NID_SEPERATOR */
+  ];
+  checkParams.forEach((param) => {
+    invalidChars.forEach((char) => {
+      if (param[1].includes(char)) {
+        throw new Error(`Invalid character inside [${param[0]}:${param[1]}], no [${char}] allowed`);
+      }
+    });
+  });
+};
+const defaultLogger = {
+  debug(message) {
+    console.log(chalk$1.grey(`debug: ${message}`));
+  },
+  error(message) {
+    console.log(chalk$1.red(`error: ${message}`));
+  },
+  http(message) {
+    console.log(chalk$1.cyan(`http: ${message}`));
+  },
+  info(message) {
+    console.log(chalk$1.white(`info: ${message}`));
+  },
+  silly(message) {
+    console.log(chalk$1.yellow(`silly: ${message}`));
+  },
+  verbose(message) {
+    console.log(chalk$1.green(`verbose: ${message}`));
+  },
+  warn(message) {
+    console.log(chalk$1.magenta(`warn: ${message}`));
+  }
+};
 function GetErrorPayload(errorCode, details = null) {
   return {
     error: errorCode.code,
@@ -1579,55 +1625,475 @@ function compareParameterTypes(source1, source2, authParameterTypes) {
   }
   return errors;
 }
-var ModelDelimeter = /* @__PURE__ */ ((ModelDelimeter2) => {
-  ModelDelimeter2["ROOT"] = "_";
-  ModelDelimeter2["SEPERATOR"] = "|";
-  ModelDelimeter2["COMPONENT_SEPERATOR"] = "@";
-  ModelDelimeter2["NID_SEPERATOR"] = "^";
-  return ModelDelimeter2;
-})(ModelDelimeter || {});
-const CheckValidChar = (checkParams) => {
-  const invalidChars = [
-    "_",
-    "|",
-    "@",
-    "^"
-    /* NID_SEPERATOR */
-  ];
-  checkParams.forEach((param) => {
-    invalidChars.forEach((char) => {
-      if (param[1].includes(char)) {
-        throw new Error(`Invalid character inside [${param[0]}:${param[1]}], no [${char}] allowed`);
+var byteToHex = [];
+for (var i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+var getRandomValues;
+var rnds8 = new Uint8Array(16);
+function rng() {
+  if (!getRandomValues) {
+    getRandomValues = typeof crypto !== "undefined" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
+    if (!getRandomValues) {
+      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+    }
+  }
+  return getRandomValues(rnds8);
+}
+var randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+const native = {
+  randomUUID
+};
+function v4(options, buf, offset) {
+  if (native.randomUUID && !buf && !options) {
+    return native.randomUUID();
+  }
+  options = options || {};
+  var rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  return unsafeStringify(rnds);
+}
+class GenericMessageManager {
+  constructor(options) {
+    __privateAdd(this, _id);
+    __privateAdd(this, _options2);
+    __privateAdd(this, _inflightMessages, {});
+    __privateAdd(this, _messageHeader);
+    __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, _SendMessage, (payload, options, callBack, errorCallBack) => {
+      const messageId = v4();
+      const requestPayload = {
+        header: __privateGet(this, _messageHeader),
+        messageId,
+        senderId: __privateGet(this, _id),
+        senderRole: __privateGet(this, _options2).role,
+        requestPayload: payload,
+        responsePayload: {},
+        pid: process.pid.toString(),
+        messageType: "REQUEST"
+      };
+      const messageRecord = {
+        messageId,
+        senderId: __privateGet(this, _id),
+        senderRole: __privateGet(this, _options2).role,
+        requestPayload,
+        responses: {},
+        // record
+        startTime: performance.now(),
+        endTime: 0,
+        timeout: setTimeout(() => {
+          setTimeout(() => {
+            delete __privateGet(this, _inflightMessages)[messageRecord.messageId];
+          }, 0).unref();
+          errorCallBack(requestPayload);
+        }, __privateGet(this, _options2).requestResponseMessageTimeout).unref(),
+        // max message timeout allowed
+        callBack,
+        errorCallBack
+      };
+      __privateGet(this, _inflightMessages)[messageRecord.messageId] = messageRecord;
+      __privateGet(this, _options2).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, _options2).ProcessResponseMessage) {
+            completed = await __privateGet(this, _options2).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 ;
+        }
       }
     });
-  });
-};
-const defaultLogger = {
-  debug(message) {
-    console.log(chalk$1.grey(`debug: ${message}`));
-  },
-  error(message) {
-    console.log(chalk$1.red(`error: ${message}`));
-  },
-  http(message) {
-    console.log(chalk$1.cyan(`http: ${message}`));
-  },
-  info(message) {
-    console.log(chalk$1.white(`info: ${message}`));
+    __publicField(this, "Start", (options) => {
+      __privateSet(this, _messageHeader, `__STS__${__privateGet(this, _options2).namespace}__${v4()}`);
+      __privateGet(this, _options2).messageReceiverStart(options);
+    });
+    __publicField(this, "Stop", (options) => {
+      __privateGet(this, _options2).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, _options2).namespace}__`;
+        if (msg.header.includes(checkName)) {
+          const message = msg;
+          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 = __privateGet(this, _options2).groups.indexOf(group) === -1 ? false : true;
+            }
+            if (processMessage) {
+              message.responsePayload = await __privateGet(this, _options2).ProcessRequestMessage(message, options);
+              message.senderId = __privateGet(this, _id);
+              message.messageType = "RESPONSE";
+              __privateGet(this, _options2).messageSender(message, options);
+            }
+          } else {
+            __privateGet(this, _ProcessMessage).call(this, msg, options);
+          }
+        }
+      }
+    });
+    __privateSet(this, _id, v4());
+    __privateSet(this, _options2, options);
+    __privateSet(this, _messageHeader, `__STS__${__privateGet(this, _options2).namespace}__${v4()}`);
+  }
+  get id() {
+    return __privateGet(this, _id);
+  }
+  // eslint-disable-next-line  @typescript-eslint/no-unused-vars
+  ReceivedMessageFromMaster(msg) {
+  }
+}
+_id = new WeakMap();
+_options2 = new WeakMap();
+_inflightMessages = new WeakMap();
+_messageHeader = new WeakMap();
+_SendMessage = new WeakMap();
+_ProcessMessage = new WeakMap();
+var tinyEmitter = { exports: {} };
+function E() {
+}
+E.prototype = {
+  on: function(name, callback, ctx) {
+    var e = this.e || (this.e = {});
+    (e[name] || (e[name] = [])).push({
+      fn: callback,
+      ctx
+    });
+    return this;
   },
-  silly(message) {
-    console.log(chalk$1.yellow(`silly: ${message}`));
+  once: function(name, callback, ctx) {
+    var self = this;
+    function listener() {
+      self.off(name, listener);
+      callback.apply(ctx, arguments);
+    }
+    listener._ = callback;
+    return this.on(name, listener, ctx);
   },
-  verbose(message) {
-    console.log(chalk$1.green(`verbose: ${message}`));
+  emit: function(name) {
+    var data = [].slice.call(arguments, 1);
+    var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
+    var i = 0;
+    var len = evtArr.length;
+    for (i; i < len; i++) {
+      evtArr[i].fn.apply(evtArr[i].ctx, data);
+    }
+    return this;
   },
-  warn(message) {
-    console.log(chalk$1.magenta(`warn: ${message}`));
+  off: function(name, callback) {
+    var e = this.e || (this.e = {});
+    var evts = e[name];
+    var liveEvents = [];
+    if (evts && callback) {
+      for (var i = 0, len = evts.length; i < len; i++) {
+        if (evts[i].fn !== callback && evts[i].fn._ !== callback)
+          liveEvents.push(evts[i]);
+      }
+    }
+    liveEvents.length ? e[name] = liveEvents : delete e[name];
+    return this;
   }
 };
+tinyEmitter.exports = E;
+var TinyEmitter = tinyEmitter.exports.TinyEmitter = E;
+class WebWorkerMessageHandler extends TinyEmitter {
+  // MessagePort;
+  constructor(options) {
+    super();
+    __privateAdd(this, _ipcMessageManager, null);
+    __privateAdd(this, _options3);
+    __privateAdd(this, _events, {});
+    __privateAdd(this, _clients, {});
+    __privateAdd(this, _pingTimeout, null);
+    __privateAdd(this, _messagePort);
+    __privateAdd(this, _processRawMessage, (rawmessage) => {
+      var _a;
+      const message = JSON.parse(rawmessage);
+      (_a = __privateGet(this, _ipcMessageManager)) == null ? void 0 : _a.ProcessMessage(message, {});
+    });
+    __publicField(this, "AddGroup", (group) => {
+      const index = __privateGet(this, _options3).groups.indexOf(group);
+      if (index === -1) {
+        __privateGet(this, _options3).groups.push(group);
+      }
+    });
+    __publicField(this, "RemoveGroup", (group) => {
+      const removeIndex = __privateGet(this, _options3).groups.indexOf(group);
+      if (removeIndex !== -1) {
+        __privateGet(this, _options3).groups.splice(removeIndex, 1);
+      }
+    });
+    __publicField(this, "SetupPrimary", () => {
+      const ipcMessageManagerOptions = {
+        logger: __privateGet(this, _options3).logger,
+        requestResponseMessageTimeout: 5e3,
+        namespace: __privateGet(this, _options3).namespace,
+        role: __privateGet(this, _options3).role,
+        messageSender: __privateGet(this, _messageSender),
+        groups: __privateGet(this, _options3).groups,
+        // 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, _messagePort).on("message", __privateGet(this, _processRawMessage));
+        },
+        messageReceiverStop: (options) => {
+          __privateGet(this, _messagePort).off("message", __privateGet(this, _processRawMessage));
+        }
+      };
+      __privateSet(this, _ipcMessageManager, new GenericMessageManager(ipcMessageManagerOptions));
+    });
+    __privateAdd(this, _messageSender, (payload, options) => {
+      if (payload.messageType.localeCompare("REQUEST") === 0) {
+        __privateGet(this, _messagePort).postMessage(JSON.stringify(payload));
+      } else if (payload.messageType.localeCompare("RESPONSE") === 0) {
+        __privateGet(this, _messagePort).postMessage(JSON.stringify(payload));
+      }
+    });
+    __privateAdd(this, _ProcessResponseMessage, async (responses, options) => {
+      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;
+      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) {
+          if (payload.requestPayload["__eventName"]) {
+            const eventName = payload.requestPayload["__eventName"];
+            if (__privateGet(this, _events)[eventName]) {
+              try {
+                __privateGet(this, _events)[eventName].callback(...payload.requestPayload.args, (responseMessage) => {
+                  resolve(responseMessage);
+                });
+              } catch (error) {
+                reject(error);
+              }
+            }
+          }
+        }
+      });
+    });
+    __publicField(this, "Start", () => {
+      var _a;
+      (_a = __privateGet(this, _ipcMessageManager)) == 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, _ipcMessageManager)) == null ? void 0 : _a.Stop();
+    });
+    __publicField(this, "emitex", async (event, ...args) => {
+      return __privateGet(this, _ipcMessageManager).SendMessage({
+        __eventName: event,
+        args
+      });
+    });
+    __privateSet(this, _options3, options);
+    __privateSet(this, _messagePort, options.messagePort);
+    this.SetupPrimary();
+    if (__privateGet(this, _options3).role.localeCompare("CLIENT") === 0) {
+      const ping = () => {
+        __privateSet(this, _pingTimeout, setTimeout(() => {
+          const pingData = {
+            id: __privateGet(this, _ipcMessageManager).id,
+            groups: __privateGet(this, _options3).groups
+          };
+          if (__privateGet(this, _options3).context) {
+            pingData.context = __privateGet(this, _options3).context;
+          }
+          this.emit("ping", pingData, (response) => {
+          });
+          ping();
+        }, 1e3).unref());
+      };
+      ping();
+    } else {
+      this.on("ping", (pingData, callback) => {
+        const { id, groups, context } = 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].context = context;
+        } else {
+          __privateGet(this, _clients)[id] = {
+            id,
+            clientConnected: /* @__PURE__ */ new Date(),
+            pingCount: 0,
+            timeout: setTimeout(() => {
+              delete __privateGet(this, _clients)[id];
+            }, 2e3),
+            groups,
+            context
+          };
+        }
+        callback("ok");
+      });
+    }
+  }
+  get clients() {
+    return __privateGet(this, _clients);
+  }
+  get groups() {
+    return __privateGet(this, _options3).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, _ipcMessageManager)) == null ? void 0 : _a.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;
+          }
+        }
+        __privateGet(this, _options3).logger.error(chalk$1.red(`RedisMessageHandler:emit(): Error: [${JSON.stringify(error)}]`));
+      }
+    })();
+    return this;
+  }
+  emitWithError(event, args, responseCb, errorCb) {
+    (async () => {
+      var _a;
+      try {
+        const retVal = await ((_a = __privateGet(this, _ipcMessageManager)) == null ? void 0 : _a.SendMessage({
+          __eventName: event,
+          args: [args]
+        }));
+        responseCb(retVal);
+      } catch (error) {
+        if (__privateGet(this, _options3).ignoreEvents) {
+          if (__privateGet(this, _options3).ignoreEvents.indexOf(error.__eventName) !== -1) {
+            return;
+          }
+        }
+        errorCb(error);
+      }
+    })();
+    return this;
+  }
+}
+_ipcMessageManager = new WeakMap();
+_options3 = new WeakMap();
+_events = new WeakMap();
+_clients = new WeakMap();
+_pingTimeout = new WeakMap();
+_messagePort = new WeakMap();
+_processRawMessage = new WeakMap();
+_messageSender = new WeakMap();
+_ProcessResponseMessage = new WeakMap();
+_processPayload = new WeakMap();
 export {
   AddSchema,
   CheckValidChar,
+  GenericMessageManager,
   GetErrorPayload,
   JestSleep,
   ModelDelimeter,
@@ -1638,6 +2104,7 @@ export {
   STSOptionsBase,
   Sleep,
   Validate,
+  WebWorkerMessageHandler,
   compareParameterTypes,
   defaultLogger
 };