@yarkivaev/scada 1.4.0 → 2.3.45

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

@@ -0,0 +1,72 @@
+/**
+ * PostgreSQL user_decisions port for segment and operation audit.
+ *
+ * list(machine, start) returns segment chronology.
+ * listByKey(machine, key) returns operation chronology by payload.key.
+ * insert writes one audit row.
+ *
+ * @param {object} pool - pg pool
+ * @returns {object} catalog with list, listByKey, insert
+ *
+ * @example
+ *   const catalog = userDecisionsFromPg(pool);
+ *   await catalog.insert({
+ *     machine: 'm1', startTime: new Date(), username: 'Ivan',
+ *     decidedAt: new Date(), payload: { kind: 'operation_op', verb: 'create', key: 'bath:m1:1' }
+ *   });
+ */
+function mapRow(row) {
+    const item = {
+        username: row.username,
+        decidedAt: row.decided_at,
+        payload: row.payload
+    };
+    if (row.operator_id !== undefined && row.operator_id !== null) {
+        item.operatorId = row.operator_id;
+    }
+    return item;
+}
+
+export default function userDecisionsFromPg(pool) {
+    return {
+        async list(machine, start) {
+            const result = await pool.query(
+                `SELECT username, operator_id, decided_at, payload
+                 FROM user_decisions
+                 WHERE machine = $1 AND start_time = $2
+                 ORDER BY decided_at ASC NULLS LAST`,
+                [machine, start]
+            );
+            return result.rows.map(mapRow);
+        },
+        async listByKey(machine, key) {
+            const result = await pool.query(
+                `SELECT username, operator_id, decided_at, payload
+                 FROM user_decisions
+                 WHERE machine = $1
+                   AND (payload::jsonb->>'key') = $2
+                 ORDER BY decided_at ASC NULLS LAST`,
+                [machine, key]
+            );
+            return result.rows.map(mapRow);
+        },
+        async insert(row) {
+            const payload = typeof row.payload === 'string'
+                ? row.payload
+                : JSON.stringify(row.payload);
+            await pool.query(
+                `INSERT INTO user_decisions
+                 (machine, start_time, username, operator_id, decided_at, payload)
+                 VALUES ($1, $2, $3, $4, $5, $6)`,
+                [
+                    row.machine,
+                    row.startTime,
+                    row.username,
+                    row.operatorId ?? null,
+                    row.decidedAt,
+                    payload
+                ]
+            );
+        }
+    };
+}

package/src/infrastructure/persistence/postgresPool.js

@@ -0,0 +1,24 @@
+import pg from 'pg';
+
+/**
+ * Creates a PostgreSQL pool for supervisor state reads.
+ *
+ * @param {object} [options] - optional existing pool or connection string
+ * @returns {object|undefined} pg pool
+ *
+ * @example
+ *   const pool = postgresPool({ connectionString: process.env.SUPERVISOR_STATE_PG_URL });
+ */
+export default function postgresPool(options = {}) {
+    if (options.pool) {
+        return options.pool;
+    }
+    const url = options.connectionString
+        || process.env.SUPERVISOR_STATE_PG_URL
+        || process.env.SUPERVISOR_STATE_DATABASE_URL
+        || process.env.POSTGRES_URL;
+    if (!url) {
+        return undefined;
+    }
+    return new pg.Pool({ connectionString: url });
+}

package/src/infrastructure/persistence/stateDataFromMemory.js

@@ -0,0 +1,28 @@
+import alertsStateMemory from './memory/alerts.js';
+import checkpointStateMemory from './memory/checkpoints.js';
+import metricsStateMemory from './memory/metrics.js';
+import operationStateMemory from './memory/operations.js';
+import segmentStateMemory from './memory/segments.js';
+
+/**
+ * In-memory supervisor state bundle for tests and local runs.
+ *
+ * @param {object} [initial] - optional seed segments, metrics, alerts
+ * @returns {object} state data ports with shared seed store
+ */
+export default function stateDataFromMemory(initial = {}) {
+    const store = {
+        segments: [...(initial.segments || [])],
+        metrics: [...(initial.metrics || [])],
+        alerts: [...(initial.alerts || [])],
+        operations: [...(initial.operations || [])]
+    };
+    return {
+        segments: segmentStateMemory(store),
+        metrics: metricsStateMemory(store),
+        alerts: alertsStateMemory(store),
+        checkpoints: checkpointStateMemory(store),
+        operations: operationStateMemory(store),
+        seed: store
+    };
+}

package/src/infrastructure/persistence/stateDataFromPool.js

@@ -0,0 +1,18 @@
+import alertsStatePg from './pg/alerts.js';
+import checkpointStatePg from './pg/checkpoints.js';
+import metricsStateDisabled from './memory/metricsDisabled.js';
+import metricsStatePg from './pg/metrics.js';
+import operationStatePg from './pg/operations.js';
+import segmentStatePg from './pg/segments.js';
+
+export default function stateDataFromPool(pool, options = {}) {
+    const metricsEnabled = options.metricsEnabled !== false;
+    const metrics = metricsEnabled ? metricsStatePg(pool) : metricsStateDisabled();
+    return {
+        segments: segmentStatePg(pool),
+        alerts: alertsStatePg(pool),
+        metrics,
+        checkpoints: checkpointStatePg(pool, metricsEnabled),
+        operations: operationStatePg(pool)
+    };
+}

package/src/infrastructure/sync/operationCodec.js

@@ -0,0 +1,75 @@
+import processingErrorLog from '../ingest/processingErrorLog.js';
+
+function parseOccurredAt(value) {
+    const timestamp = new Date(value);
+    if (isNaN(timestamp.getTime())) {
+        throw new RangeError(`Invalid occurred_at: ${value}`);
+    }
+    return timestamp;
+}
+
+function requireString(parsed, field) {
+    if (typeof parsed[field] !== 'string') {
+        throw new Error(`Operation missing ${field} field`);
+    }
+}
+
+function requirePayload(parsed) {
+    if (typeof parsed.payload !== 'object' || parsed.payload === null || Array.isArray(parsed.payload)) {
+        throw new Error('Operation missing payload field');
+    }
+}
+
+function identity(parsed) {
+    requireString(parsed, 'machine');
+    requireString(parsed, 'kind');
+    requireString(parsed, 'external_key');
+    return {
+        machine: parsed.machine,
+        occurred_at: parseOccurredAt(parsed.occurred_at),
+        kind: parsed.kind,
+        key: parsed.external_key
+    };
+}
+
+async function decode(parsed, collector) {
+    const record = identity(parsed);
+    if (parsed.type === 'deleted') {
+        if (typeof collector.remove !== 'function') {
+            throw new Error('Collector must have a remove() method');
+        }
+        await collector.remove(record);
+        return;
+    }
+    requirePayload(parsed);
+    await collector.accept({ ...record, payload: parsed.payload });
+}
+
+/**
+ * Codec for converting AMQP operation sync messages to PostgreSQL-ready records.
+ *
+ * Upsert messages require payload. Deleted messages (type=deleted) call collector.remove.
+ *
+ * @param {object} collector - Collector with accept() and optional remove()
+ * @returns {object} Codec with accept() method
+ *
+ * @example
+ *   const codec = operationCodec(collector);
+ *   await codec.accept(Buffer.from('{"machine":"m1","occurred_at":"2024-06-01T10:00:00.000Z","kind":"chem","external_key":"nb-1","payload":{}}'));
+ *   await codec.accept(Buffer.from('{"type":"deleted","machine":"m1","occurred_at":"2024-06-01T10:00:00.000Z","kind":"bath","external_key":"k"}'));
+ */
+export default function operationCodec(collector) {
+    if (!collector || typeof collector.accept !== 'function') {
+        throw new Error('Collector must have an accept() method');
+    }
+    return {
+        async accept(content) {
+            try {
+                await decode(JSON.parse(content.toString()), collector);
+            } catch (error) {
+                processingErrorLog('operation_codec', error, { content: content.toString() });
+                throw error;
+            }
+        }
+    };
+}

package/src/infrastructure/sync/operationSyncIngest.js

@@ -0,0 +1,82 @@
+import amqp from 'amqplib';
+import operationCodec from './operationCodec.js';
+import operationSyncSink from './operationSyncSink.js';
+
+/**
+ * Decodes one AMQP operation message body through the codec.
+ *
+ * @param {object} codec - operationCodec instance
+ * @param {Buffer} content - message body
+ * @returns {Promise<void>}
+ */
+export function acceptOperationDeliver(codec, content) {
+    return codec.accept(content);
+}
+
+/**
+ * Builds a queue consumer callback bound to one AMQP channel.
+ *
+ * @param {object} codec - operationCodec instance
+ * @param {object} channel - amqplib channel with ack(msg)
+ * @returns {Function} consume callback for ch.consume
+ */
+export function operationConsumer(codec, channel) {
+    return async (msg) => {
+        if (!msg) {
+            return;
+        }
+        await acceptOperationDeliver(codec, msg.content);
+        channel.ack(msg);
+    };
+}
+
+/**
+ * AMQP queue consumer that UPSERTs federated operation events into central PG.
+ *
+ * @param {string} amqpUrl - RabbitMQ AMQP URL
+ * @param {string} queue - Durable queue name to consume
+ * @param {object} operations - Operations port with upsert(item)
+ * @param {object} [options] - prefetch options
+ * @returns {object} consumer with start and stop
+ *
+ * @example
+ *   const ingest = operationSyncIngest(amqpUrl, 'scada.operations.ingest', dataAccess.operations);
+ *   await ingest.start();
+ */
+export default function operationSyncIngest(amqpUrl, queue, operations, options = {}) {
+    const prefetch = options.prefetch || 32;
+    const sink = operationSyncSink(operations);
+    const codec = operationCodec(sink);
+    let session;
+    return {
+        async start() {
+            if (session) {
+                return;
+            }
+            const conn = await amqp.connect(amqpUrl);
+            const ch = await conn.createChannel();
+            await ch.assertQueue(queue, { durable: true });
+            ch.prefetch(prefetch);
+            const onMessage = operationConsumer(codec, ch);
+            const tag = await ch.consume(queue, onMessage, { noAck: false });
+            const started = { conn, channel: ch, tag: tag.consumerTag };
+            if (session) {
+                await ch.cancel(tag.consumerTag);
+                await ch.close();
+                await conn.close();
+                return;
+            }
+            session = started;
+        },
+        async stop() {
+            const active = session;
+            if (!active) {
+                return;
+            }
+            session = undefined;
+            await active.channel.cancel(active.tag);
+            await active.channel.close();
+            await active.conn.close();
+        }
+    };
+}

package/src/infrastructure/sync/operationSyncSink.js

@@ -0,0 +1,40 @@
+import processingErrorLog from '../ingest/processingErrorLog.js';
+
+/**
+ * PostgreSQL sink for generic operation sync records.
+ *
+ * @param {object} operations - Operations port with upsert(item) and remove(machineId, key)
+ * @returns {object} Sink with accept() and remove() methods
+ *
+ * @example
+ *   const sink = operationSyncSink(dataAccess.operations);
+ *   await sink.accept({ machine: 'm1', occurred_at: new Date(), kind: 'chem', key: 'nb-1', payload: {} });
+ *   await sink.remove({ machine: 'm1', kind: 'chem', key: 'nb-1', occurred_at: new Date() });
+ */
+export default function operationSyncSink(operations) {
+    return {
+        async accept(record) {
+            try {
+                await operations.upsert(record);
+            } catch (error) {
+                processingErrorLog('operation_sync_sink', error, {
+                    machine: record.machine,
+                    key: record.key
+                });
+                throw error;
+            }
+        },
+        async remove(record) {
+            try {
+                await operations.remove(record.machine, record.key);
+            } catch (error) {
+                processingErrorLog('operation_sync_sink', error, {
+                    machine: record.machine,
+                    key: record.key,
+                    action: 'remove'
+                });
+                throw error;
+            }
+        }
+    };
+}

package/src/activeMelting.js

@@ -1,54 +0,0 @@
-import meltingChronology from './meltingChronology.js';
-import completedMelting from './completedMelting.js';
-
-/**
- * In-progress melting session that can be stopped to produce a completed melting.
- * Chronology is bound to machine and derives values from machine's weight history.
- * Notifies callbacks when stopped or updated.
- *
- * @param {string} id - unique melting session identifier
- * @param {object} machine - the melting machine running this session
- * @param {Date} start - when the melting session started
- * @param {function} onStop - callback invoked with completedMelting when stopped
- * @param {function} onUpdate - callback invoked when melting is updated
- * @returns {object} active melting with id, machine, chronology, stop, update methods
- *
- * @example
- *   const active = activeMelting('m1', machine, new Date(), onStop, onUpdate);
- *   machine.load(500);
- *   machine.dispense(480);
- *   const completed = active.stop();
- */
-export default function activeMelting(id, machine, start, onStop, onUpdate) {
-    return {
-        id() {
-            return id;
-        },
-        machine() {
-            return machine;
-        },
-        chronology() {
-            return meltingChronology(machine, start, undefined);
-        },
-        stop() {
-            const end = new Date();
-            const chron = meltingChronology(machine, start, end);
-            const completed = completedMelting(id, machine, chron, onUpdate);
-            onStop(completed);
-            return completed;
-        },
-        update(data) {
-            const opts = data === undefined ? {} : data;
-            const newStart = opts.start === undefined ? start : new Date(opts.start);
-            if (opts.end !== undefined) {
-                const chron = meltingChronology(machine, newStart, new Date(opts.end));
-                const completed = completedMelting(id, machine, chron, onUpdate);
-                onStop(completed);
-                return completed;
-            }
-            const updated = activeMelting(id, machine, newStart, onStop, onUpdate);
-            onUpdate(updated);
-            return updated;
-        }
-    };
-}

package/src/completedMelting.js

@@ -1,42 +0,0 @@
-import meltingChronology from './meltingChronology.js';
-
-/**
- * Immutable record of a finished melting session.
- * Chronology is bound to machine and derives values from machine's weight history.
- * Notifies callback when updated.
- *
- * @param {string} id - unique melting session identifier
- * @param {object} machine - the machine that performed this melting
- * @param {object} chron - chronology bound to machine with start/end times
- * @param {function} onUpdate - callback invoked when melting is updated
- * @returns {object} completed melting with id, machine, chronology, update methods
- *
- * @example
- *   const completed = completedMelting('m1', machine, chron, onUpdate);
- *   completed.id(); // 'm1'
- *   completed.chronology().get().start; // start time
- *   completed.chronology().get().end; // end time
- */
-export default function completedMelting(id, machine, chron, onUpdate) {
-    return {
-        id() {
-            return id;
-        },
-        machine() {
-            return machine;
-        },
-        chronology() {
-            return chron;
-        },
-        update(data) {
-            const opts = data === undefined ? {} : data;
-            const original = chron.get();
-            const newStart = opts.start === undefined ? original.start : new Date(opts.start);
-            const newEnd = opts.end === undefined ? original.end : new Date(opts.end);
-            const updated = meltingChronology(machine, newStart, newEnd);
-            const result = completedMelting(id, machine, updated, onUpdate);
-            onUpdate(result);
-            return result;
-        }
-    };
-}

package/src/event.js

@@ -1,24 +0,0 @@
-/**
- * Immutable event record with properties and labels.
- * Represents a single occurrence in the system log.
- *
- * @param {string} id - unique event identifier
- * @param {Date} timestamp - when the event occurred
- * @param {object} properties - event-specific data
- * @param {string[]} labels - classification tags for the event
- * @returns {object} event with id, timestamp, properties, labels methods
- *
- * @example
- *   const e = event('ev-1', new Date(), {machine: 'icht1', voltage: 340}, ['sensor']);
- *   e.id();         // 'ev-1'
- *   e.labels();     // ['sensor']
- *   e.properties(); // {machine: 'icht1', voltage: 340}
- */
-export default function event(id, timestamp, properties, labels) {
-    return {
-        id: () => {return id},
-        timestamp: () => {return timestamp},
-        properties: () => {return properties},
-        labels: () => {return [...labels]}
-    };
-}

package/src/events.js

@@ -1,51 +0,0 @@
-import pubsub from './pubsub.js';
-
-/**
- * Append-only event log for system occurrences.
- * Events are immutable and never modified after creation.
- * Optionally evaluates rules when events are created.
- *
- * @param {function} factory - factory function to create event records
- * @param {object} rules - optional rules collection to evaluate on create
- * @returns {object} log with create, all, find, stream methods
- *
- * @example
- *   const log = events(event, rules([rule1, rule2]));
- *   const e = log.create(new Date(), {machine: 'icht1'}, ['sensor']);
- *   log.all();                              // returns all events
- *   log.all((e) => e.labels().includes('sensor')); // filter events
- *   log.find('ev-0');                       // find by id
- *   log.stream((evt) => console.log(evt));  // subscribe to new events
- */
-export default function events(factory, rules) {
-    const items = [];
-    const bus = pubsub();
-    let counter = 0;
-    return {
-        create(timestamp, properties, labels) {
-            const id = `ev-${counter}`;
-            counter += 1;
-            const tags = labels === undefined ? [] : labels;
-            const e = factory(id, timestamp, properties, tags);
-            items.push(e);
-            bus.emit({ type: 'created', event: e });
-            if (rules !== undefined) {
-                rules.evaluate({ event: e });
-            }
-            return e;
-        },
-        all(...filters) {
-            return items.filter((e) => {
-                return filters.every((filter) => {
-                    return filter(e);
-                });
-            });
-        },
-        find(id) {
-            return items.find((e) => {
-                return e.id() === id;
-            });
-        },
-        stream: bus.stream
-    };
-}

package/src/interval.js

@@ -1,18 +0,0 @@
-/**
- * Periodic action executor wrapping setInterval.
- *
- * @param {number} period - interval in milliseconds
- * @param {function} action - callback to execute periodically
- * @returns {object} interval with start method
- *
- * @example
- *   const i = interval(1000, function() { console.log('tick'); });
- *   i.start();
- */
-export default function interval(period, action) {
-    return {
-        start() {
-            setInterval(action, period);
-        }
-    };
-}

package/src/machineChronology.js

@@ -1,79 +0,0 @@
-/**
- * Immutable chronology that queries shared machine weight history.
- * Supports point-in-time and range queries via query object.
- * Optionally includes sensor readings in current snapshot.
- *
- * @param {number} initial - initial weight when machine was created
- * @param {array} history - shared mutable array of { timestamp, weight } entries
- * @param {object} sensors - optional sensor objects keyed by name with current() method
- * @returns {object} chronology with get method
- *
- * @example
- *   const history = [{ timestamp: new Date(), weight: 0 }];
- *   const chron = machineChronology(0, history, { voltage: sensor });
- *   chron.get({ type: 'current' }).weight; // current weight
- *   chron.get({ type: 'current' }).voltage; // current voltage reading
- *   chron.get({ type: 'point', at: someDate }).weight; // weight at someDate
- *   chron.get({ type: 'range', from: start, to: end }); // { loaded, dispensed }
- */
-// eslint-disable-next-line max-lines-per-function
-export default function machineChronology(initial, history, sensors) {
-    async function current() {
-        const result = { weight: history[history.length - 1].weight };
-        if (sensors) {
-            const keys = Object.keys(sensors);
-            const values = await Promise.all(keys.map((key) => {
-                return sensors[key].current();
-            }));
-            keys.forEach((key, i) => {
-                result[key] = values[i].found ? values[i] : { value: 0, unit: '' };
-            });
-        }
-        return result;
-    }
-    function point(datetime) {
-        const time = new Date(datetime).getTime();
-        for (let i = history.length - 1; i >= 0; i -= 1) {
-            if (history[i].timestamp.getTime() <= time) {
-                return { weight: history[i].weight };
-            }
-        }
-        return { weight: initial };
-    }
-    function range(from, to) {
-        const start = new Date(from).getTime();
-        const end = new Date(to).getTime();
-        const entries = history.filter((entry) => {
-            const time = entry.timestamp.getTime();
-            return time >= start && time < end;
-        });
-        let loaded = 0;
-        let dispensed = 0;
-        const base = point(from).weight;
-        let previous = base;
-        for (const entry of entries) {
-            const delta = entry.weight - previous;
-            if (delta > 0) {
-                loaded += delta;
-            } else if (delta < 0) {
-                dispensed += Math.abs(delta);
-            }
-            previous = entry.weight;
-        }
-        return { loaded, dispensed };
-    }
-    return {
-        get(query) {
-            if (query.type === 'current') {
-                return current();
-            }
-            if (query.type === 'point') {
-                return point(query.at);
-            }
-            if (query.type === 'range') {
-                return range(query.from, query.to);
-            }
-            throw new Error(`Unknown query type: ${query.type}`);
-        }
-    };
-}

package/src/meltingChronology.js

@@ -1,37 +0,0 @@
-/**
- * Melting chronology bound to a machine.
- * Derives values from machine's weight history during the melting window.
- *
- * @param {object} machine - melting machine with chronology method
- * @param {Date} start - melting start time
- * @param {Date} end - melting end time (undefined for active meltings)
- * @returns {object} chronology with get method
- *
- * @example
- *   const chron = meltingChronology(machine, startTime, endTime);
- *   chron.get(); // { start, end, initial, weight, loaded, dispensed }
- *   chron.get(someTime); // state at specific time
- */
-export default function meltingChronology(machine, start, end) {
-    return {
-        get(datetime) {
-            const machineChron = machine.chronology();
-            const defaultTime = end === undefined ? new Date() : end;
-            const queryTime = datetime === undefined ? defaultTime : datetime;
-            const initial = machineChron.get({ type: 'point', at: start }).weight;
-            const current = machineChron.get({ type: 'point', at: queryTime }).weight;
-            const range = machineChron.get({ type: 'range', from: start, to: queryTime });
-            const result = {
-                start,
-                initial,
-                weight: current,
-                loaded: range.loaded,
-                dispensed: range.dispensed
-            };
-            if (end !== undefined) {
-                result.end = end;
-            }
-            return result;
-        }
-    };
-}