@yarkivaev/scada 2.3.52 → 2.3.54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yarkivaev/scada",
-  "version": "2.3.52",
+  "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/operationRoute.js

@@ -2,7 +2,8 @@ import machineInPlant from '../../../../application/machineInPlant.js';
 import operationJson from '../json/operationJson.js';
 import timelineOperator from '../timelineOperator.js';
 import operationWrites from './operationWrites.js';
-import { jsonResponse, route } from '@yarkivaev/simple-server';
+import httpOperations from '../../../messaging/ownership/httpOperations.js';
+import { jsonResponse, route, sendRouteError } from '@yarkivaev/simple-server';
 
 function parseRange(query) {
     const range = {};
@@ -29,11 +30,31 @@ function resolveKinds(query) {
     return undefined;
 }
 
+function edgePort(owners, machineId) {
+    if (!owners || typeof owners.resolve !== 'function') {
+        return undefined;
+    }
+    const owner = owners.resolve(machineId);
+    if (!owner || owner.kind !== 'edge') {
+        return undefined;
+    }
+    return httpOperations(owner, machineId);
+}
+
+async function listLocal(plant, machineId, query) {
+    const rows = await plant.operations.listForMachine(
+        machineId,
+        resolveKinds(query),
+        parseRange(query)
+    );
+    return { items: rows.map(operationJson) };
+}
+
 /**
  * Operations REST routes for machine-scoped reads and writes.
  *
  * Writes resolve operator via timelineOperator and stamp payload.operator.
- * Edge-owned machines proxy create/update/delete to the owning plant API
+ * Edge-owned machines proxy list/create/update/delete to the owning plant API
  * (no local upsert or decision insert). Optional owners registry mirrors timeline.
  *
  * @param {string} basePath - base URL path
@@ -60,12 +81,16 @@ export default function operationRoute(basePath, plant, operatorOptions, decisio
                 jsonResponse({ items: [] }).send(res);
                 return;
             }
-            const rows = await plant.operations.listForMachine(
-                params.machineId,
-                resolveKinds(query),
-                parseRange(query)
-            );
-            jsonResponse({ items: rows.map(operationJson) }).send(res);
+            try {
+                const port = edgePort(owners, params.machineId);
+                const listed = port
+                    ? await port.list(query)
+                    : await listLocal(plant, params.machineId, query);
+                const items = Array.isArray(listed && listed.items) ? listed.items : [];
+                jsonResponse({ items }).send(res);
+            } catch (err) {
+                sendRouteError(res, err);
+            }
         }),
         route('POST', `${basePath}/machines/:machineId/operations`, async (req, res, params) => {
             await writes.writeCreate(params.machineId, req, res);

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();

package/src/infrastructure/messaging/ownership/httpOperations.js

@@ -2,6 +2,18 @@ function trimBase(url) {
     return String(url).replace(/\/$/u, '');
 }
 
+function listPath(root, query) {
+    const params = new URLSearchParams();
+    Object.keys(query || {}).forEach((name) => {
+        const value = query[name];
+        if (value !== undefined && value !== null && value !== '') {
+            params.set(name, String(value));
+        }
+    });
+    const suffix = params.toString();
+    return suffix.length > 0 ? `${root}?${suffix}` : root;
+}
+
 function authHeaders(token) {
     const headers = { 'Content-Type': 'application/json' };
     if (token) {
@@ -33,65 +45,77 @@ async function readJson(res) {
     return JSON.parse(text);
 }
 
+function ownerContext(site, machineId) {
+    return {
+        base: trimBase(site.baseUrl),
+        fetcher: site.fetch || fetch,
+        token: site.token,
+        machineId
+    };
+}
+
+async function send(ctx, method, path, body) {
+    const url = `${ctx.base}${path}`;
+    let res;
+    try {
+        res = await ctx.fetcher(url, {
+            method,
+            headers: authHeaders(ctx.token),
+            body: body === undefined ? undefined : JSON.stringify(body)
+        });
+    } catch (cause) {
+        throw ownerError(
+            `owner operations unreachable for ${ctx.machineId}: ${cause.message}`,
+            'SERVICE_UNAVAILABLE',
+            503,
+            cause
+        );
+    }
+    if (!res.ok) {
+        throw ownerError(
+            `owner operations ${method} ${path} for ${ctx.machineId} failed: ${res.status} ${await readError(res)}`,
+            'BAD_GATEWAY',
+            502
+        );
+    }
+    return readJson(res);
+}
+
 /**
- * HTTP operations write port that proxies create/update/delete to an edge plant API.
+ * HTTP operations port that proxies list/create/update/delete to an edge plant API.
  *
  * Matches the owning-edge contract: central never upserts locally for edge machines.
  * Failures surface as route errors (503 unreachable, 502 non-ok).
  *
  * @param {object} site - edge owner with baseUrl and optional token/fetch
  * @param {string} machineId - machine identifier
- * @returns {object} operations write port
+ * @returns {object} operations port
  *
  * @example
  *   const port = httpOperations({ baseUrl: 'http://edge/api/v1' }, 'm2');
  *   await port.create({ kind: 'load', payload: {}, operatorId: 2 });
  */
 export default function httpOperations(site, machineId) {
-    const base = trimBase(site.baseUrl);
-    const fetcher = site.fetch || fetch;
-    async function send(method, path, body) {
-        const url = `${base}${path}`;
-        let res;
-        try {
-            res = await fetcher(url, {
-                method,
-                headers: authHeaders(site.token),
-                body: body === undefined ? undefined : JSON.stringify(body)
-            });
-        } catch (cause) {
-            throw ownerError(
-                `owner operations unreachable for ${machineId}: ${cause.message}`,
-                'SERVICE_UNAVAILABLE',
-                503,
-                cause
-            );
-        }
-        if (!res.ok) {
-            throw ownerError(
-                `owner operations ${method} ${path} for ${machineId} failed: ${res.status} ${await readError(res)}`,
-                'BAD_GATEWAY',
-                502
-            );
-        }
-        return readJson(res);
-    }
+    const ctx = ownerContext(site, machineId);
     const root = `/machines/${encodeURIComponent(machineId)}/operations`;
     return Object.freeze({
+        list(query) {
+            return send(ctx, 'GET', listPath(root, query));
+        },
         create(body) {
-            return send('POST', root, body);
+            return send(ctx, 'POST', root, body);
         },
         createMany(body) {
-            return send('POST', `${root}/batch`, body);
+            return send(ctx, 'POST', `${root}/batch`, body);
         },
         update(key, body) {
-            return send('PUT', `${root}/${encodeURIComponent(key)}`, body);
+            return send(ctx, 'PUT', `${root}/${encodeURIComponent(key)}`, body);
         },
         remove(key, body) {
-            return send('DELETE', `${root}/${encodeURIComponent(key)}`, body);
+            return send(ctx, 'DELETE', `${root}/${encodeURIComponent(key)}`, body);
         },
         decisions(key) {
-            return send('GET', `${root}/${encodeURIComponent(key)}/decisions`).then((body) => {
+            return send(ctx, 'GET', `${root}/${encodeURIComponent(key)}/decisions`).then((body) => {
                 return Array.isArray(body && body.items) ? body.items : [];
             });
         }