@yarkivaev/scada 2.3.53 → 2.3.54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yarkivaev/scada",
-  "version": "2.3.53",
+  "version": "2.3.54",
   "description": "SCADA domain objects, state persistence, and plant monitoring",
   "repository": {
     "type": "git",

package/src/application/plantApi.js

@@ -12,12 +12,16 @@ import simulationRoute from '../infrastructure/http/plant/routes/simulationRoute
 import catalogRoute from '../infrastructure/http/plant/routes/catalogRoute.js';
 import { routes } from '@yarkivaev/simple-server';
 
+function pass(_id, rows) {
+    return rows;
+}
+
 /**
  * Composable plant HTTP API factory.
  *
  * @param {string} basePath - base URL path
  * @param {object} plant - plant domain object with operations (optional kindSources at construction)
- * @param {object} [config] - clock, extraRoutes, requestTimeoutMs, heartbeat
+ * @param {object} [config] - clock, extraRoutes, requestTimeoutMs, heartbeat, decorateTimeline
  * @returns {object} routes with list() and handle()
  *
  * @example
@@ -30,6 +34,7 @@ export default function plantApi(basePath, plant, config) {
         return new Date();
     });
     const extra = opts.extraRoutes || [];
+    const decorate = opts.decorateTimeline || pass;
     const routeList = [
         ...catalogRoute(basePath, opts.tagCatalog),
         ...machineRoute(basePath, plant),
@@ -37,8 +42,8 @@ export default function plantApi(basePath, plant, config) {
         ...measurementRoute(basePath, plant, time),
         ...alertStream(basePath, plant, time),
         ...alertRoute(basePath, plant),
-        ...timelineRoute(basePath, plant, opts.timelineOperator),
-        ...timelineStream(basePath, plant, time),
+        ...timelineRoute(basePath, plant, opts.timelineOperator, decorate),
+        ...timelineStream(basePath, plant, time, decorate),
         ...operationRoute(basePath, plant, opts.timelineOperator, opts.operationDecisions, opts.owners),
         ...operationStream(basePath, plant, time),
         ...heartbeatStream(basePath, time, opts.heartbeat),

package/src/application/plantServer.js

@@ -72,7 +72,7 @@ async function initStomp(stomp, translations, requirePool) {
  * Multi-kind operations come from plant.operations built with kindSources
  * (e.g. plantOperations(persistence, { temp })).
  *
- * @param {object} config - port, basePath, plantFactory, extraRoutes, translations, stomp, requirePool
+ * @param {object} config - port, basePath, plantFactory, extraRoutes, translations, stomp, requirePool, decorateTimeline
  * @returns {Promise<object>} server, plant, api, segments
  *
  * @example
@@ -95,7 +95,8 @@ export default async function plantServer(config) {
         extraRoutes: extra,
         timelineOperator: config.timelineOperator,
         operationDecisions: config.operationDecisions,
-        owners: config.owners
+        owners: config.owners,
+        decorateTimeline: config.decorateTimeline
     });
     const server = http.createServer((req, res) => {
         return api.handle(req, res);

package/src/application/siteServer.js

@@ -142,7 +142,7 @@ function siteExtraRoutes(catalog, extraRoutes) {
 /**
  * Unified site process: supervisor-sink HTTP, plant API, and optional MQTT ingest.
  *
- * @param {object} config - port, basePath, translations, requirePool, plantFactory, extraRoutes, operatorCatalog, kindSources, streams, env
+ * @param {object} config - port, basePath, translations, requirePool, plantFactory, extraRoutes, operatorCatalog, kindSources, streams, env, decorateTimeline
  * @returns {Promise<object>} sink, plant, mqtt pipeline
  *
  * @example
@@ -185,7 +185,8 @@ export default async function siteServer(config) {
         extraRoutes: siteExtraRoutes(catalog, config.extraRoutes),
         timelineOperator: timelineOperatorFromEnv(catalog, env, config),
         operationDecisions: catalog.decisions,
-        owners: config.owners
+        owners: config.owners,
+        decorateTimeline: config.decorateTimeline
     });
     return { sink, plant, mqtt, telemetry, operationSync, operatorsSync: catalog.sync };
 }

package/src/infrastructure/http/plant/routes/timelineRoute.js

@@ -9,12 +9,16 @@ async function handleOperatorWrite(gate, parsed, write) {
     await write(audit);
 }
 
-async function rejectUnknownTags(timeline, parsed, machineId, res) {
+async function rejectUnknownTags(timeline, parsed, machineId, res, decorate) {
     if (typeof timeline.rowAt !== 'function') {
         return false;
     }
     const row = await timeline.rowAt(new Date(parsed.start));
-    if (!row || allowedSegmentTags(row.options, row.tags, parsed.tags)) {
+    if (!row) {
+        return false;
+    }
+    const [gated] = await decorate(machineId, [row]);
+    if (allowedSegmentTags(gated.options, gated.tags, parsed.tags)) {
         return false;
     }
     errorResponse('BAD_REQUEST', `Tag is not in segment options for ${machineId}`, 400).send(res);
@@ -41,12 +45,13 @@ async function respondToRequest(gate, timeline, requestId, req, res) {
  * @param {string} basePath - base URL path
  * @param {object} plant - plant domain object
  * @param {object} [operatorOptions] - provider, requireOperator, defaultUser
+ * @param {function} decorate - (machineId, rows) => rows, applied before JSON and PATCH gate
  * @returns {array} route objects
  *
  * @example
  *   timelineRoute('/api/v1', plant, { provider, requireOperator: true, defaultUser: 'hmi-kiosk' });
  */
-export default function timelineRoute(basePath, plant, operatorOptions) {
+export default function timelineRoute(basePath, plant, operatorOptions, decorate) {
     const gate = timelineOperator(operatorOptions);
     return [
         route('GET', `${basePath}/machines/:machineId/segments`, async (req, res, params, query) => {
@@ -62,7 +67,7 @@ export default function timelineRoute(basePath, plant, operatorOptions) {
             if (query.to) {
                 options.to = query.to;
             }
-            const rows = await result.machine.timeline.list(options);
+            const rows = await decorate(params.machineId, await result.machine.timeline.list(options));
             jsonResponse({ items: rows.map(segmentJson) }).send(res);
         }),
         route('PATCH', `${basePath}/machines/:machineId/segments`, async (req, res, params) => {
@@ -74,7 +79,7 @@ export default function timelineRoute(basePath, plant, operatorOptions) {
             try {
                 const raw = await readBody(req);
                 const parsed = JSON.parse(raw);
-                if (await rejectUnknownTags(result.machine.timeline, parsed, params.machineId, res)) {
+                if (await rejectUnknownTags(result.machine.timeline, parsed, params.machineId, res, decorate)) {
                     return;
                 }
                 await handleOperatorWrite(gate, parsed, async (audit) => {
@@ -94,7 +99,7 @@ export default function timelineRoute(basePath, plant, operatorOptions) {
                 jsonResponse({ items: [] }).send(res);
                 return;
             }
-            const rows = await result.machine.timeline.pending();
+            const rows = await decorate(params.machineId, await result.machine.timeline.pending());
             const items = rows.map(({ id, name, start_time: startTime, end_time: endTime, duration, options }) => {
                 return {
                     id,

package/src/infrastructure/http/plant/streams/timelineStream.js

@@ -22,18 +22,53 @@ function segmentPayload(segment) {
     return data;
 }
 
+async function emitSegment(sse, event, decorate, machineId) {
+    if (event.type === 'created' && event.segment) {
+        const [row] = await decorate(machineId, [event.segment]);
+        sse.emit('segment_created', segmentPayload(row));
+        return;
+    }
+    if (event.type === 'resolved' && event.segment) {
+        const [row] = await decorate(machineId, [event.segment]);
+        sse.emit('segment_resolved', segmentPayload(row));
+    }
+}
+
+async function emitRequest(sse, event, decorate, machineId) {
+    if (event.type === 'created' && event.request) {
+        const [row] = await decorate(machineId, [event.request]);
+        const start = row.start_time || row.startTime;
+        const end = row.end_time || row.endTime;
+        sse.emit('request_created', {
+            id: row.id,
+            segment: {
+                name: row.name,
+                start: start.toISOString(),
+                end: end.toISOString(),
+                duration: row.duration
+            },
+            options: row.options
+        });
+        return;
+    }
+    if (event.type === 'resolved' && event.request) {
+        sse.emit('request_resolved', { id: event.request.id });
+    }
+}
+
 /**
  * Timeline SSE routes for segments and label requests.
  *
  * @param {string} basePath - base URL path
  * @param {object} plant - plant domain object
  * @param {function} clock - time provider
+ * @param {function} decorate - (machineId, rows) => rows
  * @returns {array} route objects
  *
  * @example
  *   timelineStream('/api/v1', plant, clock);
  */
-export default function timelineStream(basePath, plant, clock) {
+export default function timelineStream(basePath, plant, clock, decorate) {
     return [
         route('GET', `${basePath}/machines/:machineId/segments/stream`, (req, res, params) => {
             const sse = sseResponse(res, clock);
@@ -44,11 +79,7 @@ export default function timelineStream(basePath, plant, clock) {
                 return;
             }
             const subscription = result.machine.timeline.stream((event) => {
-                if (event.type === 'created' && event.segment) {
-                    sse.emit('segment_created', segmentPayload(event.segment));
-                } else if (event.type === 'resolved' && event.segment) {
-                    sse.emit('segment_resolved', segmentPayload(event.segment));
-                }
+                return emitSegment(sse, event, decorate, params.machineId);
             });
             const heartbeat = setInterval(() => {
                 sse.heartbeat();
@@ -67,23 +98,7 @@ export default function timelineStream(basePath, plant, clock) {
                 return;
             }
             const subscription = result.machine.timeline.stream((event) => {
-                if (event.type === 'created' && event.request) {
-                    const reqItem = event.request;
-                    const start = reqItem.start_time || reqItem.startTime;
-                    const end = reqItem.end_time || reqItem.endTime;
-                    sse.emit('request_created', {
-                        id: reqItem.id,
-                        segment: {
-                            name: reqItem.name,
-                            start: start.toISOString(),
-                            end: end.toISOString(),
-                            duration: reqItem.duration
-                        },
-                        options: reqItem.options
-                    });
-                } else if (event.type === 'resolved' && event.request) {
-                    sse.emit('request_resolved', { id: event.request.id });
-                }
+                return emitRequest(sse, event, decorate, params.machineId);
             });
             const heartbeat = setInterval(() => {
                 sse.heartbeat();