@yarkivaev/scada 1.1.6 → 1.3.0

package/index.js

@@ -35,6 +35,10 @@ export { default as meltingRuleEngine } from './src/meltingRuleEngine.js';
 export { alert, acknowledgedAlert } from './src/alert.js';
 export { default as alerts } from './src/alerts.js';
 
+// Timeline
+export { default as segments } from './src/segments.js';
+export { default as requests } from './src/requests.js';
+
 // Utilities
 export { default as interval } from './src/interval.js';
 export { default as initialized } from './src/initialized.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yarkivaev/scada",
-  "version": "1.1.6",
+  "version": "1.3.0",
   "description": "SCADA domain objects for plant monitoring",
   "repository": {
     "type": "git",

package/src/clickhouseSensor.js

@@ -39,7 +39,7 @@ export default function clickhouseSensor(connection, topic, displayName, unit) {
             if (rows.length === 0) {
                 return { timestamp: new Date(), value: 0, unit };
             }
-            return { timestamp: new Date(rows[0].ts), value: rows[0].value, unit };
+            return { timestamp: new Date(`${rows[0].ts}Z`), value: rows[0].value, unit };
         },
         async measurements(range, step) {
             const seconds = Math.max(1, Math.floor(step / 1000));
@@ -60,21 +60,22 @@ export default function clickhouseSensor(connection, topic, displayName, unit) {
                 }
             );
             return rows.map((row) => {
-                return { timestamp: new Date(row.ts), value: row.value, unit };
+                return { timestamp: new Date(`${row.ts}Z`), value: row.value, unit };
             });
         },
-        stream(since, step, callback) {
+        stream(since, step, callback, clock) {
+            const time = clock || (() => { return new Date(); });
             let lastTs = since;
             const timer = setInterval(async () => {
                 try {
                     const rows = await connection.query(
                         `SELECT ts, value FROM scada.metrics
-                         WHERE topic = {topic:String} AND ts > {since:DateTime64(3)}
+                         WHERE topic = {topic:String} AND ts > {since:DateTime64(3)} AND ts <= {until:DateTime64(3)}
                          ORDER BY ts LIMIT 100`,
-                        { topic, since: formatDateTime(lastTs) }
+                        { topic, since: formatDateTime(lastTs), until: formatDateTime(time()) }
                     );
                     rows.forEach((row) => {
-                        const timestamp = new Date(row.ts);
+                        const timestamp = new Date(`${row.ts}Z`);
                         callback({ timestamp, value: row.value, unit });
                         lastTs = timestamp;
                     });

package/src/requests.js

@@ -0,0 +1,44 @@
+import pubsub from './pubsub.js';
+
+/**
+ * Per-machine in-memory label request collection.
+ * Stores requests for segment labeling with options for the user to choose from.
+ * Supports responding to requests and streaming events via pubsub.
+ *
+ * @returns {object} collection with add, respond, query, stream methods
+ *
+ * @example
+ *   const reqs = requests();
+ *   reqs.add({ id: 'req-0', name: 'unknown', startTime: new Date(), endTime: new Date(), duration: 60, options: ['on', 'off'] });
+ *   reqs.respond('req-0', { label: 'on' }); // marks resolved
+ *   reqs.query(); // returns unresolved requests
+ *   const sub = reqs.stream((e) => console.log(e));
+ *   sub.cancel();
+ */
+export default function requests() {
+    const items = [];
+    const bus = pubsub();
+    return {
+        add(request) {
+            items.push({ ...request, resolved: false });
+            bus.emit({ type: 'created', request });
+        },
+        respond(id, body) {
+            const found = items.find((r) => {
+                return r.id === id && !r.resolved;
+            });
+            if (!found) {
+                return undefined;
+            }
+            found.resolved = true;
+            bus.emit({ type: 'resolved', request: found });
+            return { id, ...body };
+        },
+        query() {
+            return items.filter((r) => {
+                return !r.resolved;
+            });
+        },
+        stream: bus.stream
+    };
+}

package/src/scyllaSensor.js

@@ -31,12 +31,13 @@ export default function scyllaSensor(connection, topic, displayName, unit) {
                 return { timestamp: row.ts, value: row.value, unit };
             });
         },
-        stream(since, step, callback) {
+        stream(since, step, callback, clock) {
+            const time = clock || (() => { return new Date(); });
             let lastTs = since;
             const timer = setInterval(async () => {
                 const rows = await connection.query(
-                    'SELECT ts, value FROM scada.metrics WHERE topic = ? AND ts > ? LIMIT 100',
-                    [topic, lastTs]
+                    'SELECT ts, value FROM scada.metrics WHERE topic = ? AND ts > ? AND ts <= ? LIMIT 100',
+                    [topic, lastTs, time()]
                 );
                 rows.forEach((row) => {
                     callback({ timestamp: row.ts, value: row.value, unit });

package/src/segments.js

@@ -0,0 +1,52 @@
+import pubsub from './pubsub.js';
+
+/**
+ * Per-machine in-memory timeline segment collection.
+ * Stores segments with name, startTime, endTime, duration.
+ * Supports relabeling by startTime and streaming events via pubsub.
+ *
+ * @returns {object} collection with add, relabel, query, stream methods
+ *
+ * @example
+ *   const segs = segments();
+ *   segs.add({ name: 'on', startTime: new Date(), endTime: new Date(), duration: 60 });
+ *   segs.relabel(startTime, 'heating');
+ *   segs.query(); // all segments
+ *   segs.query({ from: '2024-01-01', to: '2024-01-02' }); // filtered
+ *   const sub = segs.stream((e) => console.log(e));
+ *   sub.cancel();
+ */
+export default function segments() {
+    const items = [];
+    const bus = pubsub();
+    return {
+        add(segment) {
+            items.push(segment);
+            bus.emit({ type: 'created', segment });
+        },
+        relabel(start, name) {
+            const found = items.find((item) => {
+                return item.startTime.getTime() === start.getTime();
+            });
+            if (found) {
+                found.name = name;
+                bus.emit({ type: 'relabeled', segment: found });
+            }
+        },
+        query(options) {
+            if (!options) {
+                return items.slice();
+            }
+            return items.filter((item) => {
+                if (options.from && item.endTime < new Date(options.from)) {
+                    return false;
+                }
+                if (options.to && item.startTime > new Date(options.to)) {
+                    return false;
+                }
+                return true;
+            });
+        },
+        stream: bus.stream
+    };
+}