@machinemetrics/mm-react-tools 2.1.1 → 2.2.0-dev

package/dist/index.modern.js

@@ -544,11 +544,165 @@ function _taggedTemplateLiteralLoose(strings, raw) {
 }
 
 // A type of promise-like that resolves synchronously and supports only one observer
+const _Pact = /*#__PURE__*/(function() {
+	function _Pact() {}
+	_Pact.prototype.then = function(onFulfilled, onRejected) {
+		const result = new _Pact();
+		const state = this.s;
+		if (state) {
+			const callback = state & 1 ? onFulfilled : onRejected;
+			if (callback) {
+				try {
+					_settle(result, 1, callback(this.v));
+				} catch (e) {
+					_settle(result, 2, e);
+				}
+				return result;
+			} else {
+				return this;
+			}
+		}
+		this.o = function(_this) {
+			try {
+				const value = _this.v;
+				if (_this.s & 1) {
+					_settle(result, 1, onFulfilled ? onFulfilled(value) : value);
+				} else if (onRejected) {
+					_settle(result, 1, onRejected(value));
+				} else {
+					_settle(result, 2, value);
+				}
+			} catch (e) {
+				_settle(result, 2, e);
+			}
+		};
+		return result;
+	};
+	return _Pact;
+})();
+
+// Settles a pact synchronously
+function _settle(pact, state, value) {
+	if (!pact.s) {
+		if (value instanceof _Pact) {
+			if (value.s) {
+				if (state & 1) {
+					state = value.s;
+				}
+				value = value.v;
+			} else {
+				value.o = _settle.bind(null, pact, state);
+				return;
+			}
+		}
+		if (value && value.then) {
+			value.then(_settle.bind(null, pact, state), _settle.bind(null, pact, 2));
+			return;
+		}
+		pact.s = state;
+		pact.v = value;
+		const observer = pact.o;
+		if (observer) {
+			observer(pact);
+		}
+	}
+}
+
+function _isSettledPact(thenable) {
+	return thenable instanceof _Pact && thenable.s & 1;
+}
 
 const _iteratorSymbol = /*#__PURE__*/ typeof Symbol !== "undefined" ? (Symbol.iterator || (Symbol.iterator = Symbol("Symbol.iterator"))) : "@@iterator";
 
 const _asyncIteratorSymbol = /*#__PURE__*/ typeof Symbol !== "undefined" ? (Symbol.asyncIterator || (Symbol.asyncIterator = Symbol("Symbol.asyncIterator"))) : "@@asyncIterator";
 
+// Asynchronously implement a generic for loop
+function _for(test, update, body) {
+	var stage;
+	for (;;) {
+		var shouldContinue = test();
+		if (_isSettledPact(shouldContinue)) {
+			shouldContinue = shouldContinue.v;
+		}
+		if (!shouldContinue) {
+			return result;
+		}
+		if (shouldContinue.then) {
+			stage = 0;
+			break;
+		}
+		var result = body();
+		if (result && result.then) {
+			if (_isSettledPact(result)) {
+				result = result.s;
+			} else {
+				stage = 1;
+				break;
+			}
+		}
+		if (update) {
+			var updateValue = update();
+			if (updateValue && updateValue.then && !_isSettledPact(updateValue)) {
+				stage = 2;
+				break;
+			}
+		}
+	}
+	var pact = new _Pact();
+	var reject = _settle.bind(null, pact, 2);
+	(stage === 0 ? shouldContinue.then(_resumeAfterTest) : stage === 1 ? result.then(_resumeAfterBody) : updateValue.then(_resumeAfterUpdate)).then(void 0, reject);
+	return pact;
+	function _resumeAfterBody(value) {
+		result = value;
+		do {
+			if (update) {
+				updateValue = update();
+				if (updateValue && updateValue.then && !_isSettledPact(updateValue)) {
+					updateValue.then(_resumeAfterUpdate).then(void 0, reject);
+					return;
+				}
+			}
+			shouldContinue = test();
+			if (!shouldContinue || (_isSettledPact(shouldContinue) && !shouldContinue.v)) {
+				_settle(pact, 1, result);
+				return;
+			}
+			if (shouldContinue.then) {
+				shouldContinue.then(_resumeAfterTest).then(void 0, reject);
+				return;
+			}
+			result = body();
+			if (_isSettledPact(result)) {
+				result = result.v;
+			}
+		} while (!result || !result.then);
+		result.then(_resumeAfterBody).then(void 0, reject);
+	}
+	function _resumeAfterTest(shouldContinue) {
+		if (shouldContinue) {
+			result = body();
+			if (result && result.then) {
+				result.then(_resumeAfterBody).then(void 0, reject);
+			} else {
+				_resumeAfterBody(result);
+			}
+		} else {
+			_settle(pact, 1, result);
+		}
+	}
+	function _resumeAfterUpdate() {
+		if (shouldContinue = test()) {
+			if (shouldContinue.then) {
+				shouldContinue.then(_resumeAfterTest).then(void 0, reject);
+			} else {
+				_resumeAfterTest(shouldContinue);
+			}
+		} else {
+			_settle(pact, 1, result);
+		}
+	}
+}
+
 // Asynchronously call a function and send errors to recovery continuation
 function _catch(body, recover) {
 	try {
@@ -562,6 +716,19 @@ function _catch(body, recover) {
 	return result;
 }
 
+// Asynchronously await a promise and pass the result to a finally continuation
+function _finallyRethrows(body, finalizer) {
+	try {
+		var result = body();
+	} catch (e) {
+		return finalizer(true, e);
+	}
+	if (result && result.then) {
+		return result.then(finalizer.bind(null, false), finalizer.bind(null, true));
+	}
+	return finalizer(false, result);
+}
+
 var MMAuthContext = React.createContext();
 
 var MMAuthInternalContext = React.createContext();
@@ -1189,8 +1356,9 @@ var Authorize = function Authorize(_ref) {
   return !isAuthenticated ? /*#__PURE__*/React.createElement(Message, null, "Authorizing...") : /*#__PURE__*/React.createElement(Done, null);
 };
 
-var ApolloApp = function ApolloApp(_ref) {
+var DataWrapper = function DataWrapper(_ref) {
   var jwtRef = _ref.jwtRef,
+      natsCredsRef = _ref.natsCredsRef,
       graphQLRoleOverride = _ref.graphQLRoleOverride,
       clientId = _ref.clientId,
       accessToken = _ref.accessToken;
@@ -1299,6 +1467,7 @@ var ApolloApp = function ApolloApp(_ref) {
   return /*#__PURE__*/React.createElement(MMAuthInternalContext.Provider, {
     value: {
       link: link,
+      natsCredsRef: natsCredsRef,
       jwtRef: jwtRef,
       clientId: clientId,
       accessToken: accessToken
@@ -1323,10 +1492,7 @@ var MMJwtProvider = function MMJwtProvider(_ref) {
       setIsAuthenticated = _useState[1];
 
   var jwtRef = useRef();
-
-  var _useState2 = useState(),
-      natsCreds = _useState2[0],
-      setNatsCreds = _useState2[1];
+  var natsCredsRef = useRef();
 
   var logout = function logout() {
     try {
@@ -1393,13 +1559,13 @@ var MMJwtProvider = function MMJwtProvider(_ref) {
   useAsyncInterval(function () {
     try {
       if (!accessToken) {
-        setNatsCreds();
+        natsCredsRef.current = null;
         return Promise.resolve();
       }
 
       var _temp5 = _catch(function () {
         return Promise.resolve(request(urls.apiUrl + "/nats-token")).then(function (response) {
-          setNatsCreds(response);
+          natsCredsRef.current = response;
         });
       }, function () {});
 
@@ -1414,8 +1580,7 @@ var MMJwtProvider = function MMJwtProvider(_ref) {
       login: login,
       logout: logout,
       request: request,
-      urls: urls,
-      natsCreds: natsCreds
+      urls: urls
     }
   }, /*#__PURE__*/React.createElement(Routes, null, /*#__PURE__*/React.createElement(Route, {
     exact: true,
@@ -1425,10 +1590,11 @@ var MMJwtProvider = function MMJwtProvider(_ref) {
     })
   }), /*#__PURE__*/React.createElement(Route, {
     path: "/",
-    element: /*#__PURE__*/React.createElement(ApolloApp, {
+    element: /*#__PURE__*/React.createElement(DataWrapper, {
       clientId: clientId,
       graphQLRoleOverride: graphQLRoleOverride,
       jwtRef: jwtRef,
+      natsCredsRef: natsCredsRef,
       accessToken: accessToken
     })
   }, children))));
@@ -1472,21 +1638,26 @@ var MMProvider = function MMProvider(_ref) {
       clientId = _ref.clientId,
       clientSecret = _ref.clientSecret,
       releaseStage = _ref.releaseStage,
-      graphQLRoleOverride = _ref.graphQLRoleOverride;
+      graphQLRoleOverride = _ref.graphQLRoleOverride,
+      customUrls = _ref.urls;
 
   if (releaseStage === 'release') {
     releaseStage = 'production';
     console.warn("releaseStage \"release\" has been deprecated. use \"production\" instead.");
   }
 
-  var urls = URL_MAP[releaseStage];
+  var urls;
 
-  if (!urls) {
+  if (URL_MAP[releaseStage]) {
+    urls = URL_MAP[releaseStage];
+  } else {
     var stages = _.keys(URL_MAP).join(', ');
 
     throw Error("MMProvider releaseStage must be one of the following: " + stages);
   }
 
+  urls = _.merge(urls, customUrls);
+
   var _useState = useState(retrieveAccessToken()),
       accessToken = _useState[0],
       setAccessToken = _useState[1];
@@ -1574,17 +1745,14 @@ var MMProvider = function MMProvider(_ref) {
   }));
 };
 
+var ALLOWED_DELIVERY_POLICIES = ['new', 'last', 'last_per_subject'];
+
 var connectToServer = function connectToServer(url, creds) {
   try {
-    var credentialsBytes = new TextEncoder().encode(creds);
-    return Promise.resolve(_catch(function () {
-      return Promise.resolve(connect({
-        servers: [url],
-        authenticator: credsAuthenticator(credentialsBytes)
-      }));
-    }, function (error) {
-      console.error("Error connecting to server: " + error.message);
-      throw error;
+    console.info("Connecting to server " + url);
+    return Promise.resolve(connect({
+      servers: [url],
+      authenticator: credsAuthenticator(new TextEncoder().encode(creds))
     }));
   } catch (e) {
     return Promise.reject(e);
@@ -1631,7 +1799,7 @@ function _decode() {
           case 14:
             _context.prev = 14;
             _context.t0 = _context["catch"](9);
-            console.warn("Skipping event\n" + JSON.stringify(event, null, 2) + "\n" + _context.t0);
+            console.warn("Skipping event: " + _context.t0);
 
           case 17:
             _iteratorAbruptCompletion = false;
@@ -1686,67 +1854,212 @@ function _decode() {
   return _decode.apply(this, arguments);
 }
 
-var useEventStream = function useEventStream(_ref) {
-  var streamName = _ref.streamName,
-      subject = _ref.subject;
+var closeConnection = function closeConnection(eventStreamRef, connectionRef) {
+  if (eventStreamRef.current) {
+    eventStreamRef.current = undefined;
+  }
+
+  if (connectionRef.current) {
+    connectionRef.current.close();
+    connectionRef.current = undefined;
+  }
+};
+
+var streamPatterns = {
+  scada: 'mm.0.[location-ref].[machine-ref].[qualifier].[data-category].[metric-key].[message-type]',
+  'machine-service': 'mm.2.[location-ref].[machine-ref].[service-name].[qualifier].[data-category].[metric-key].[message-type]',
+  'edge-service': 'mm.3.[location-ref].[edge-ref].[service-name].[data-category].[metric-key].[message-type]',
+  'machine-source-service': 'mm.4.[location-ref].[machine-ref].[machine-source-ref].[service-name].[data-category].[metric-key].[message-type]',
+  edge: 'mm.7.[location-ref].[edge-ref].[data-category].[metric-key].[message-type]'
+};
+var dataCategoryMapping = {
+  undefined: 0,
+  event: 1,
+  eventset: 2,
+  quantity: 3,
+  state: 4,
+  count: 5,
+  info: 6,
+  beat: 7
+};
+
+var buildSubject = function buildSubject(streamName, locationRef, filter) {
+  if (!streamPatterns[streamName]) {
+    throw new Error('Unknown stream name');
+  }
+
+  var pattern = streamPatterns[streamName].split('.');
+  var subject = '';
+  pattern.forEach(function (part, index) {
+    switch (part) {
+      case '[location-ref]':
+        subject += '.' + locationRef;
+        break;
+
+      case '[machine-ref]':
+        subject += '.' + ((filter === null || filter === void 0 ? void 0 : filter.machineRef) || '*');
+        break;
+
+      case '[qualifier]':
+        subject += '.' + ((filter === null || filter === void 0 ? void 0 : filter.qualifier) || '0');
+        break;
+
+      case '[data-category]':
+        subject += '.' + (dataCategoryMapping[filter === null || filter === void 0 ? void 0 : filter.dataCategory] || '*');
+        break;
+
+      case '[metric-key]':
+        subject += '.' + (filter !== null && filter !== void 0 && filter.metricKey ? filter === null || filter === void 0 ? void 0 : filter.metricKey.toLowerCase().replace(/[^a-zA-Z0-9_\\-]/gi, '-') : '*');
+        break;
+
+      case '[message-type]':
+        subject += '.' + ((filter === null || filter === void 0 ? void 0 : filter.messageType) || '0');
+        break;
+
+      case '[edge-ref]':
+        subject += '.' + ((filter === null || filter === void 0 ? void 0 : filter.edgeRef) || '*');
+        break;
+
+      case '[service-name]':
+        subject += '.' + ((filter === null || filter === void 0 ? void 0 : filter.serviceName) || '*');
+        break;
+
+      case '[machine-source-ref]':
+        subject += '.' + ((filter === null || filter === void 0 ? void 0 : filter.machineSourceRef) || '*');
+        break;
+
+      default:
+        if (index > 0) {
+          subject += '.';
+        }
+
+        subject += part;
+        break;
+    }
+  });
+  return subject;
+};
+
+var useEventStream = function useEventStream(params) {
+  var streamName = params.streamName,
+      locationRef = params.locationRef,
+      filters = params.filters,
+      _params$deliverPolicy = params.deliverPolicy,
+      deliverPolicy = _params$deliverPolicy === void 0 ? 'new' : _params$deliverPolicy,
+      dispatch = params.dispatch;
+
+  if (!ALLOWED_DELIVERY_POLICIES.includes(deliverPolicy)) {
+    throw new Error("Invalid deliverPolicy \"" + deliverPolicy + "\" specified. Valid options are: " + ALLOWED_DELIVERY_POLICIES.join(', '));
+  }
+
+  if (filters && filters.length > 1) {
+    console.warn("Multiple filters are not supported. Only the first filter will be used.");
+  }
 
   var _useMMAuth = useMMAuth(),
-      natsCreds = _useMMAuth.natsCreds,
       urls = _useMMAuth.urls;
 
-  var _useState = useState(),
-      connection = _useState[0],
-      setConnection = _useState[1];
-
-  var _useState2 = useState(),
-      eventStream = _useState2[0],
-      setEventStream = _useState2[1];
+  var _useMMAuthInternal2 = _useMMAuthInternal(),
+      natsCredsRef = _useMMAuthInternal2.natsCredsRef;
 
+  var connectionRef = useRef();
+  var eventStreamRef = useRef();
   useEffect(function () {
-    if (eventStream === undefined) {
-      if (natsCreds && subject) {
-        connectToServer(urls.natsUrl, natsCreds).then(function (conn) {
-          try {
-            var _temp2 = function _temp2(stream) {
-              return jc.consumers.get(stream, {
-                filterSubjects: subject,
-                deliver_policy: 'last_per_subject'
-              });
-            };
+    if (!urls.natsUrl || !natsCredsRef.current || !streamName || !locationRef) return;
 
-            setConnection(conn);
-            var jc = conn.jetstream();
-            console.log('Consuming from subject:', subject);
-            return Promise.resolve(streamName ? _temp2(streamName) : Promise.resolve(jc.findStream(subject)).then(_temp2));
-          } catch (e) {
-            return Promise.reject(e);
-          }
-        }).then(function (consumer) {
-          try {
-            return Promise.resolve(consumer.consume({
-              max_messages: 1000
-            })).then(function (messages) {
-              var events = decode(messages);
-              setEventStream(events);
+    var setupStream = function setupStream() {
+      try {
+        return Promise.resolve(_catch(function () {
+          return Promise.resolve(connectToServer(urls.natsUrl, natsCredsRef.current)).then(function (conn) {
+            connectionRef.current = conn;
+            var subject = buildSubject(streamName, locationRef, filters === null || filters === void 0 ? void 0 : filters[0]);
+            console.info("Consuming events from stream " + streamName + " filtering by subject " + subject);
+            return Promise.resolve(conn.jetstream().consumers.get(streamName, {
+              deliver_policy: deliverPolicy,
+              filterSubjects: subject
+            })).then(function (consumer) {
+              return Promise.resolve(consumer.consume({
+                max_messages: 1000
+              })).then(function (messages) {
+                var eventStream = decode(messages);
+                eventStreamRef.current = eventStream;
+                return function () {
+                  if (typeof dispatch === 'function') {
+                    var _iteratorAbruptCompletion2 = false;
+                    var _didIteratorError2 = false;
+
+                    var _iteratorError2;
+
+                    return _finallyRethrows(function () {
+                      return _catch(function () {
+                        var _iterator2 = _asyncIterator(eventStream),
+                            _step2;
+
+                        var _temp = _for(function () {
+                          return Promise.resolve(_iterator2.next()).then(function (_iterator2$next) {
+                            return _iteratorAbruptCompletion2 = !(_step2 = _iterator2$next).done;
+                          });
+                        }, function () {
+                          return !!(_iteratorAbruptCompletion2 = false);
+                        }, function () {
+                          var event = _step2.value;
+                          dispatch(event);
+                        });
+
+                        if (_temp && _temp.then) return _temp.then(function () {});
+                      }, function (err) {
+                        _didIteratorError2 = true;
+                        _iteratorError2 = err;
+                      });
+                    }, function (_wasThrown, _result2) {
+                      var _exit = false;
+
+                      function _temp4(_result3) {
+                        if (_exit) return _result3;
+                        if (_wasThrown) throw _result2;
+                        return _result2;
+                      }
+
+                      var _temp3 = _finallyRethrows(function () {
+                        var _temp2 = function () {
+                          if (_iteratorAbruptCompletion2 && _iterator2["return"] != null) {
+                            return Promise.resolve(_iterator2["return"]()).then(function () {});
+                          }
+                        }();
+
+                        if (_temp2 && _temp2.then) return _temp2.then(function () {});
+                      }, function (_wasThrown2, _result3) {
+                        if (_didIteratorError2) {
+                          throw _iteratorError2;
+                        }
+
+                        if (_wasThrown2) throw _result3;
+                        return _result3;
+                      });
+
+                      return _temp3 && _temp3.then ? _temp3.then(_temp4) : _temp4(_temp3);
+                    });
+                  }
+                }();
+              });
             });
-          } catch (e) {
-            return Promise.reject(e);
-          }
-        });
+          });
+        }, function (error) {
+          console.error("Error setting up event stream. " + error);
+        }));
+      } catch (e) {
+        return Promise.reject(e);
       }
-    } else {
-      return function () {
-        if (eventStream) {
-          setEventStream(undefined);
-        }
+    };
 
-        if (connection) {
-          connection.close();
-        }
-      };
-    }
-  }, [subject, natsCreds]);
-  return eventStream;
+    setupStream();
+    return function () {
+      return closeConnection(eventStreamRef, connectionRef);
+    };
+  }, [streamName, locationRef, deliverPolicy, urls.natsUrl, natsCredsRef]);
+  return [eventStreamRef.current, function () {
+    return closeConnection(eventStreamRef, connectionRef);
+  }];
 };
 
 export { MMProvider, PrivateLayout, _useMMAuthInternal, useApiRequest, useAsyncEffect, useAsyncInterval, useDowntimeQuery, useEventStream, useMMAuth, useMMHash, useMMTemplates, useProductionQuery, useQuantityStream, useThrottleEffect };