@yarkivaev/scada 1.1.5 → 1.2.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.5",
+  "version": "1.2.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,23 +60,27 @@ 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) {
             let lastTs = since;
             const timer = setInterval(async () => {
-                const rows = await connection.query(
-                    `SELECT ts, value FROM scada.metrics
-                     WHERE topic = {topic:String} AND ts > {since:DateTime64(3)}
-                     ORDER BY ts LIMIT 100`,
-                    { topic, since: formatDateTime(lastTs) }
-                );
-                rows.forEach((row) => {
-                    const timestamp = new Date(row.ts);
-                    callback({ timestamp, value: row.value, unit });
-                    lastTs = timestamp;
-                });
+                try {
+                    const rows = await connection.query(
+                        `SELECT ts, value FROM scada.metrics
+                         WHERE topic = {topic:String} AND ts > {since:DateTime64(3)}
+                         ORDER BY ts LIMIT 100`,
+                        { topic, since: formatDateTime(lastTs) }
+                    );
+                    rows.forEach((row) => {
+                        const timestamp = new Date(`${row.ts}Z`);
+                        callback({ timestamp, value: row.value, unit });
+                        lastTs = timestamp;
+                    });
+                } catch (err) {
+                    console.error('Stream query failed:', err.message); // eslint-disable-line no-console
+                }
             }, step);
             return {
                 cancel() {

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/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
+    };
+}