@yarkivaev/scada 2.3.52 → 2.3.53

package/package.json

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

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/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 : [];
             });
         }