@yarkivaev/scada 2.3.51 → 2.3.53

package/package.json

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

package/src/application/plantOperations.js

@@ -6,9 +6,9 @@ import pubsub from '../domain/shared/pubsub.js';
  *
  * Optional kindSources inject non-PG kinds into listForMachine merges.
  *
- * @param {object} persistence - operations store with upsert, get, remove, listForMachine, latestForMachine
+ * @param {object} persistence - operations store with upsert, upsertMany, get, remove, listForMachine, latestForMachine
  * @param {object} [kindSources] - map of kind to { list(machineId, range) }
- * @returns {object} operations with listForMachine, latestForMachine, upsert, get, remove, and stream
+ * @returns {object} operations with listForMachine, latestForMachine, upsert, upsertMany, get, remove, and stream
  *
  * @example
  *   const ops = plantOperations(dataAccess.operations, { temp: temperaturePort });

package/src/domain/operation/operations.js

@@ -27,6 +27,34 @@ function resolveKinds(kinds, sources) {
     return [kinds];
 }
 
+function announce(bus, result, row) {
+    bus.emit({
+        type: result.created ? 'created' : 'updated',
+        operation: row
+    });
+}
+
+function writeOne(persistence, bus, item) {
+    const row = stampRow(item, new Date());
+    return persistence.upsert(row).then((result) => {
+        announce(bus, result, row);
+    });
+}
+
+function writeMany(persistence, bus, items) {
+    if (typeof persistence.upsertMany !== 'function') {
+        throw new Error('Operations persistence must have an upsertMany() method');
+    }
+    const rows = items.map((item) => {
+        return stampRow(item, new Date());
+    });
+    return persistence.upsertMany(rows).then((results) => {
+        rows.forEach((row, index) => {
+            announce(bus, results[index], row);
+        });
+    });
+}
+
 /**
  * Operations wired to persistence, pubsub, and optional non-PG kind sources.
  *
@@ -37,7 +65,7 @@ function resolveKinds(kinds, sources) {
  * @param {object} persistence - store with upsert, get, remove, listForMachine, latestForMachine
  * @param {object} bus - pubsub instance with stream and emit methods
  * @param {object} [kindSources] - map of kind to { list(machineId, range) }
- * @returns {object} operations with listForMachine, latestForMachine, upsert, get, remove, stream
+ * @returns {object} operations with listForMachine, latestForMachine, upsert, upsertMany, get, remove, stream
  *
  * @example
  *   const ops = operations(store, bus, { temp: temperaturePort });
@@ -65,12 +93,10 @@ export default function operations(persistence, bus, kindSources) {
             return persistence.latestForMachine(machineId, kind, bound);
         },
         upsert(item) {
-            const updatedAt = new Date();
-            const row = stampRow(item, updatedAt);
-            return persistence.upsert(row).then((result) => {
-                const type = result.created ? 'created' : 'updated';
-                bus.emit({ type, operation: row });
-            });
+            return writeOne(persistence, bus, item);
+        },
+        upsertMany(items) {
+            return writeMany(persistence, bus, items);
         },
         get(machineId, key) {
             return persistence.get(machineId, key);

package/src/infrastructure/client/machineOperationsClient.js

@@ -134,6 +134,14 @@ export default function machineOperationsClient(baseUrl, request, eventSource, l
         createOperation(fields) {
             return request('/operations', payload('POST', createBody(fields)));
         },
+        createOperations(list) {
+            const items = (list || []).map(createBody);
+            const data = { items };
+            if (list && list.length > 0) {
+                attachAudit(data, list[0]);
+            }
+            return request('/operations/batch', payload('POST', data));
+        },
         updateOperation(key, fields) {
             return request(
                 `/operations/${encodeURIComponent(key)}`,

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

@@ -0,0 +1,133 @@
+import machineInPlant from '../../../../application/machineInPlant.js';
+import operationJson from '../json/operationJson.js';
+import { decisionRow, stampPayload } from '../operationAudit.js';
+import { draftsFromBatch } from './operationDrafts.js';
+import httpOperations from '../../../messaging/ownership/httpOperations.js';
+import { errorResponse, jsonResponse, readBody, sendRouteError } from '@yarkivaev/simple-server';
+
+function isMissing(err) {
+    return typeof err.message === 'string' && err.message.includes('not found for machine');
+}
+
+function sendFailure(gate, res, err) {
+    if (gate && gate.sendError(res, err)) {
+        return;
+    }
+    if (err.routeCode && err.routeStatus) {
+        errorResponse(err.routeCode, err.message, err.routeStatus).send(res);
+        return;
+    }
+    if (isMissing(err)) {
+        errorResponse('NOT_FOUND', err.message, 404).send(res);
+        return;
+    }
+    sendRouteError(res, err);
+}
+
+function machineMissing(plant, machineId, res) {
+    const result = machineInPlant(plant, machineId);
+    if (!result || !plant.operations) {
+        errorResponse('NOT_FOUND', `Machine '${machineId}' not found`, 404).send(res);
+        return true;
+    }
+    return false;
+}
+
+async function record(decisions, machine, item, audit, verb) {
+    if (!decisions || typeof decisions.insert !== 'function') {
+        return;
+    }
+    await decisions.insert(decisionRow(machine, item, audit, verb));
+}
+
+async function readJson(req) {
+    if (typeof req.on !== 'function') {
+        return {};
+    }
+    const raw = await readBody(req);
+    if (!raw || String(raw).trim().length === 0) {
+        return {};
+    }
+    return JSON.parse(raw);
+}
+
+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);
+}
+
+function ownerItem(machineId, response, parsed) {
+    return {
+        machine: machineId,
+        key: (response && (response.external_key || response.key)) || parsed.key,
+        kind: (response && response.kind) || parsed.kind,
+        occurred_at: (response && response.occurred_at) || parsed.occurred_at || new Date(),
+        payload: (response && response.payload) || parsed.payload
+    };
+}
+
+function forwardBatch(parsed, audit) {
+    const body = { items: parsed.items };
+    if (audit.id !== undefined && audit.id !== null) {
+        body.operatorId = audit.id;
+    }
+    return body;
+}
+
+async function localCreateMany(ctx, machineId, parsed, audit) {
+    const drafts = draftsFromBatch(machineId, parsed);
+    drafts.forEach((item) => {
+        item.payload = stampPayload(item.payload, audit);
+    });
+    await ctx.plant.operations.upsertMany(drafts);
+    await drafts.reduce((chain, item) => {
+        return chain.then(() => {
+            return record(ctx.decisions, machineId, item, audit, 'create');
+        });
+    }, Promise.resolve());
+    return drafts;
+}
+
+/**
+ * Creates many operations in one request for a machine.
+ *
+ * Edge-owned machines proxy the batch body to the owning plant API.
+ *
+ * @param {object} ctx - plant, gate, decisions, owners
+ * @param {string} machineId - machine identifier
+ * @param {object} req - HTTP request
+ * @param {object} res - HTTP response
+ * @returns {Promise<void>}
+ */
+export default async function createMany(ctx, machineId, req, res) {
+    if (machineMissing(ctx.plant, machineId, res)) {
+        return;
+    }
+    try {
+        const parsed = await readJson(req);
+        const audit = await ctx.gate.resolve(parsed);
+        const port = edgePort(ctx.owners, machineId);
+        if (port) {
+            const created = await port.createMany(forwardBatch(parsed, audit));
+            const rows = Array.isArray(created && created.items) ? created.items : [];
+            await rows.reduce((chain, row, index) => {
+                return chain.then(() => {
+                    const source = Array.isArray(parsed.items) ? parsed.items[index] || {} : {};
+                    return record(ctx.decisions, machineId, ownerItem(machineId, row, source), audit, 'create');
+                });
+            }, Promise.resolve());
+            jsonResponse(created).send(res);
+            return;
+        }
+        const items = await localCreateMany(ctx, machineId, parsed, audit);
+        jsonResponse({ items: items.map(operationJson) }).send(res);
+    } catch (err) {
+        sendFailure(ctx.gate, res, err);
+    }
+}

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

@@ -77,3 +77,30 @@ export function draftFromUpdate(machineId, key, existing, parsed) {
         payload: parsed.payload
     };
 }
+
+const BATCH_LIMIT = 50;
+
+/**
+ * Builds create drafts from a batch POST body.
+ *
+ * @param {string} machineId - machine id
+ * @param {object} parsed - JSON body with items array
+ * @returns {Array<object>} operation drafts in request order
+ */
+export function draftsFromBatch(machineId, parsed) {
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw reject('BAD_REQUEST', 'operation body must be a JSON object', 400);
+    }
+    if (!Array.isArray(parsed.items)) {
+        throw reject('BAD_REQUEST', 'items must be an array', 400);
+    }
+    if (parsed.items.length === 0) {
+        throw reject('BAD_REQUEST', 'items must not be empty', 400);
+    }
+    if (parsed.items.length > BATCH_LIMIT) {
+        throw reject('BAD_REQUEST', `items cannot exceed ${BATCH_LIMIT} operations`, 400);
+    }
+    return parsed.items.map((item) => {
+        return draftFromBody(machineId, item);
+    });
+}

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,16 +81,23 @@ 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);
         }),
+        route('POST', `${basePath}/machines/:machineId/operations/batch`, async (req, res, params) => {
+            await writes.writeCreateMany(params.machineId, req, res);
+        }),
         route('PUT', `${basePath}/machines/:machineId/operations/:key`, async (req, res, params) => {
             await writes.writeUpdate(params.machineId, decodeURIComponent(params.key), req, res);
         }),

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

@@ -2,6 +2,7 @@ import machineInPlant from '../../../../application/machineInPlant.js';
 import operationJson from '../json/operationJson.js';
 import { decisionRow, stampPayload } from '../operationAudit.js';
 import { draftFromBody, draftFromUpdate } from './operationDrafts.js';
+import createMany from './operationBatchWrites.js';
 import httpOperations from '../../../messaging/ownership/httpOperations.js';
 import { errorResponse, jsonResponse, readBody, sendRouteError } from '@yarkivaev/simple-server';
 
@@ -169,13 +170,16 @@ async function writeDelete(ctx, machineId, key, req, res) {
  * Edge-owned machines proxy to the owning plant API without local upsert.
  *
  * @param {object} ctx - plant, gate, decisions, owners
- * @returns {object} writeCreate, writeUpdate, writeDelete
+ * @returns {object} writeCreate, writeCreateMany, writeUpdate, writeDelete
  */
 export default function operationWrites(ctx) {
     return {
         writeCreate(machineId, req, res) {
             return writeCreate(ctx, machineId, req, res);
         },
+        writeCreateMany(machineId, req, res) {
+            return createMany(ctx, machineId, req, res);
+        },
         writeUpdate(machineId, key, req, res) {
             return writeUpdate(ctx, machineId, key, 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,62 +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(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 : [];
             });
         }

package/src/infrastructure/persistence/memory/operations.js

@@ -18,6 +18,29 @@ function missing(machineId, key) {
     return new Error(`operation '${key}' not found for machine '${machineId}'`);
 }
 
+/**
+ * Inserts or replaces one in-memory operation row.
+ *
+ * @param {object} store - shared mutable store with operations array
+ * @param {object} item - operation row
+ * @returns {{created: boolean}} whether the key was new
+ */
+function putRow(store, item) {
+    const row = findRow(store, item.key);
+    if (row) {
+        row.machine = item.machine;
+        row.occurred_at = item.occurred_at;
+        row.kind = item.kind;
+        row.payload = item.payload;
+        if (item.source_updated_at) {
+            row.source_updated_at = item.source_updated_at;
+        }
+        return { created: false };
+    }
+    store.operations.push({ ...item });
+    return { created: true };
+}
+
 function filterList(store, machineId, kind, range) {
     const from = range.from ?? null;
     const to = range.to ?? null;
@@ -84,19 +107,7 @@ export default function operationStateMemory(store) {
     }
     return {
         upsert(item) {
-            const row = findRow(store, item.key);
-            if (row) {
-                row.machine = item.machine;
-                row.occurred_at = item.occurred_at;
-                row.kind = item.kind;
-                row.payload = item.payload;
-                if (item.source_updated_at) {
-                    row.source_updated_at = item.source_updated_at;
-                }
-                return Promise.resolve({ created: false });
-            }
-            store.operations.push({ ...item });
-            return Promise.resolve({ created: true });
+            return Promise.resolve(putRow(store, item));
         },
         get(machineId, key) {
             const row = findScoped(store, machineId, key);
@@ -120,6 +131,11 @@ export default function operationStateMemory(store) {
         },
         latestForMachine(machineId, kind, bound) {
             return Promise.resolve(filterLatest(store, machineId, kind, bound));
+        },
+        upsertMany(items) {
+            return Promise.resolve(items.map((item) => {
+                return putRow(store, item);
+            }));
         }
     };
 }

package/src/infrastructure/persistence/pg/operations.js

@@ -20,6 +20,33 @@ async function upsertOperation(pool, item) {
     return { created: existing.rows.length === 0 };
 }
 
+/**
+ * Inserts or updates operations in one PostgreSQL transaction.
+ *
+ * @param {object} pool - pg pool with connect()
+ * @param {Array<object>} items - operations in write order
+ * @returns {Promise<Array<{created: boolean}>>} per-row insert flags
+ */
+async function upsertMany(pool, items) {
+    const client = await pool.connect();
+    try {
+        await client.query('BEGIN');
+        const results = [];
+        await items.reduce((chain, item) => {
+            return chain.then(async () => {
+                results.push(await upsertOperation(client, item));
+            });
+        }, Promise.resolve());
+        await client.query('COMMIT');
+        return results;
+    } catch (err) {
+        await client.query('ROLLBACK');
+        throw err;
+    } finally {
+        client.release();
+    }
+}
+
 function listForMachine(pool, machineId, kind, range) {
     let sql = `SELECT machine, occurred_at, kind, key, payload
         FROM operations WHERE machine = $1 AND kind = $2`;
@@ -121,6 +148,9 @@ export default function operationStatePg(pool) {
         },
         latestForMachine(machineId, kind, bound) {
             return latestForMachine(pool, machineId, kind, bound);
+        },
+        upsertMany(items) {
+            return upsertMany(pool, items);
         }
     };
 }