@yarkivaev/scada 2.3.50 → 2.3.52

package/package.json

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

@@ -0,0 +1,41 @@
+/**
+ * Normalizes a tags or options field that may be an array or JSON string.
+ *
+ * @param {unknown} raw - stored field
+ * @returns {Array<string>} id list
+ */
+function asIds(raw) {
+    if (Array.isArray(raw)) {
+        return raw.filter((id) => {
+            return typeof id === 'string';
+        });
+    }
+    if (typeof raw === 'string' && raw.length > 0) {
+        const parsed = JSON.parse(raw);
+        return asIds(parsed);
+    }
+    return [];
+}
+
+/**
+ * Returns whether requested tags are inside published options or already standing.
+ * Empty options mean no restriction so older publishers keep working.
+ *
+ * @param {unknown} options - published option ids
+ * @param {unknown} standing - tags already on the segment
+ * @param {unknown} tags - tags the operator wants to write
+ * @returns {boolean} true when every requested tag is allowed
+ * @example
+ *   allowedSegmentTags(['load'], [], ['load'])
+ */
+export default function allowedSegmentTags(options, standing, tags) {
+    const allow = asIds(options);
+    if (allow.length === 0) {
+        return true;
+    }
+    const held = new Set(asIds(standing));
+    const published = new Set(allow);
+    return asIds(tags).every((id) => {
+        return published.has(id) || held.has(id);
+    });
+}

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

@@ -70,6 +70,9 @@ export default function operationRoute(basePath, plant, operatorOptions, decisio
         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/http/plant/routes/timelineRoute.js

@@ -1,4 +1,5 @@
 import machineInPlant from '../../../../application/machineInPlant.js';
+import allowedSegmentTags from '../allowedSegmentTags.js';
 import segmentJson from '../json/segmentJson.js';
 import timelineOperator from '../timelineOperator.js';
 import { errorResponse, jsonResponse, readBody, route, sendRouteError } from '@yarkivaev/simple-server';
@@ -8,6 +9,18 @@ async function handleOperatorWrite(gate, parsed, write) {
     await write(audit);
 }
 
+async function rejectUnknownTags(timeline, parsed, machineId, res) {
+    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)) {
+        return false;
+    }
+    errorResponse('BAD_REQUEST', `Tag is not in segment options for ${machineId}`, 400).send(res);
+    return true;
+}
+
 async function respondToRequest(gate, timeline, requestId, req, res) {
     const raw = await readBody(req);
     const parsed = JSON.parse(raw);
@@ -61,6 +74,9 @@ 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)) {
+                    return;
+                }
                 await handleOperatorWrite(gate, parsed, async (audit) => {
                     await result.machine.timeline.retag(new Date(parsed.start), parsed.tags, parsed.properties, audit);
                 });

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

@@ -81,6 +81,9 @@ export default function httpOperations(site, machineId) {
         create(body) {
             return send('POST', root, body);
         },
+        createMany(body) {
+            return send('POST', `${root}/batch`, body);
+        },
         update(key, body) {
             return send('PUT', `${root}/${encodeURIComponent(key)}`, body);
         },

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