@yarkivaev/scada 1.4.0 → 2.3.45

package/src/infrastructure/persistence/metricsSensor.js

@@ -0,0 +1,112 @@
+function parseTimestamp(ts) {
+    return ts instanceof Date ? ts : new Date(ts);
+}
+
+function pollStream(spec) {
+    const { read, topic, since, step, callback, clock, unit } = spec;
+    const time = clock || (() => {
+        return new Date();
+    });
+    let lastTs = since;
+    const timer = setInterval(async () => {
+        try {
+            const rows = await read.poll(topic, lastTs.toISOString(), time().toISOString());
+            rows.forEach((row) => {
+                const timestamp = parseTimestamp(row.ts);
+                callback({ timestamp, value: row.value, unit });
+                lastTs = timestamp;
+            });
+        } catch {
+            /* next poll retries */
+        }
+    }, step);
+    return {
+        cancel() {
+            clearInterval(timer);
+        }
+    };
+}
+
+/**
+ * Read port adapter for PostgreSQL metrics state.
+ *
+ * @param {object} metrics - metrics state port from metricsStatePg
+ * @returns {object} read port for metricsSensor
+ */
+export function pgMetricsRead(metrics) {
+    return {
+        async current(topic) {
+            const row = await metrics.latestForTopic(topic);
+            if (!row) {
+                return { found: false };
+            }
+            return { found: true, ts: row.ts, value: row.value };
+        },
+        range(topic, startIso, endIso, stepMs) {
+            return metrics.rangeForTopic(topic, startIso, endIso, stepMs);
+        },
+        poll(topic, afterIso, untilIso) {
+            return metrics.pollTopic(topic, afterIso, untilIso);
+        }
+    };
+}
+
+/**
+ * Sensor reading metrics through a generic read port.
+ *
+ * @param {object} read - port with current, range, poll
+ * @param {string} topic - metrics topic key
+ * @param {string} displayName - label
+ * @param {string} unit - unit string
+ * @returns {object} sensor with name current measurements stream
+ */
+export default function metricsSensor(read, topic, displayName, unit) {
+    return {
+        name() {
+            return displayName;
+        },
+        async current() {
+            const row = await read.current(topic);
+            if (!row.found) {
+                return { found: false };
+            }
+            return {
+                found: true,
+                timestamp: parseTimestamp(row.ts),
+                value: row.value,
+                unit
+            };
+        },
+        async measurements(range, step) {
+            const rows = await read.range(
+                topic,
+                range.start.toISOString(),
+                range.end.toISOString(),
+                step
+            );
+            return rows.map((row) => {
+                return {
+                    timestamp: parseTimestamp(row.ts),
+                    value: row.value,
+                    unit
+                };
+            });
+        },
+        stream(since, step, callback, clock) {
+            return pollStream({ read, topic, since, step, callback, clock, unit });
+        }
+    };
+}
+
+/**
+ * Sensor reading metrics from PostgreSQL metrics table in-process.
+ *
+ * @param {object} metrics - metrics state port with latestForTopic, rangeForTopic, pollTopic
+ * @param {string} topic - metrics topic key
+ * @param {string} displayName - label
+ * @param {string} unit - unit string
+ * @returns {object} sensor with name current measurements stream
+ */
+export function pgMetricsSensor(metrics, topic, displayName, unit) {
+    return metricsSensor(pgMetricsRead(metrics), topic, displayName, unit);
+}

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

@@ -0,0 +1,25 @@
+/**
+ * PostgreSQL alert hydration port for supervisor-sink and plant STOMP alerts.
+ *
+ * @param {object} pool - pg pool
+ * @returns {object} alerts port with listUnacknowledged
+ *
+ * @example
+ *   const store = alertsStatePg(pool);
+ *   const rows = await store.listUnacknowledged({ machine: 'm1' });
+ */
+export default function alertsStatePg(pool) {
+    return {
+        async listUnacknowledged(filters) {
+            let sql = 'SELECT * FROM alerts WHERE acknowledged = FALSE';
+            const prm = [];
+            if (filters.machine) {
+                prm.push(filters.machine);
+                sql += ` AND machine = $${prm.length}`;
+            }
+            sql += ' ORDER BY id';
+            const result = await pool.query(sql, prm);
+            return result.rows;
+        }
+    };
+}

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

@@ -0,0 +1,115 @@
+import segmentStatePg from './segments.js';
+
+function parseJsonField(raw) {
+    if (!raw) {
+        return null;
+    }
+    return JSON.parse(raw);
+}
+
+function segmentItem(row, machineId) {
+    if (!row) {
+        return null;
+    }
+    return {
+        machine: machineId,
+        name: row.name,
+        start: new Date(row.start_time).getTime() / 1000,
+        end: new Date(row.end_time).getTime() / 1000,
+        duration: row.duration,
+        tags: parseJsonField(row.tags),
+        options: parseJsonField(row.options),
+        properties: parseJsonField(row.properties)
+    };
+}
+
+function segmentAt(pool, machineId, startEpoch) {
+    const segments = segmentStatePg(pool);
+    const start = new Date(startEpoch * 1000);
+    return segments.rowAt(machineId, start).then((row) => {
+        return segmentItem(row, machineId);
+    });
+}
+
+function replayCursor(pool, machineId) {
+    return pool.query(
+        `WITH closed AS (
+            SELECT MAX(EXTRACT(EPOCH FROM end_time)) AS ts
+            FROM segments
+            WHERE machine = $1 AND duration > 0
+        ),
+        pending AS (
+            SELECT MAX(EXTRACT(EPOCH FROM start_time)) AS ts
+            FROM segments
+            WHERE machine = $1 AND duration = 0
+        )
+        SELECT COALESCE(LEAST(closed.ts, pending.ts), pending.ts, closed.ts, 0.0) AS cursor
+        FROM closed, pending`,
+        [machineId]
+    ).then((result) => {
+        return Number(result.rows[0].cursor || 0);
+    });
+}
+
+function pendingSegments(pool) {
+    return pool.query(
+        `SELECT machine, name,
+                EXTRACT(EPOCH FROM start_time) AS start,
+                EXTRACT(EPOCH FROM end_time) AS end
+         FROM segments
+         WHERE duration = 0`
+    ).then((result) => {
+        return result.rows.map((row) => {
+            return {
+                machine: row.machine,
+                name: row.name,
+                start: Number(row.start),
+                end: Number(row.end)
+            };
+        });
+    });
+}
+
+function readings(pool, topics, from) {
+    if (topics.length === 0) {
+        return Promise.resolve([]);
+    }
+    const placeholders = topics.map((item, index) => {
+        return `$${index + 1}`;
+    }).join(',');
+    return pool.query(
+        `SELECT topic, EXTRACT(EPOCH FROM ts) AS ts, value
+         FROM metrics
+         WHERE topic IN (${placeholders}) AND ts > to_timestamp($${topics.length + 1})
+         ORDER BY ts ASC`,
+        [...topics, from]
+    ).then((result) => {
+        return result.rows.map((row) => {
+            return {
+                topic: row.topic,
+                timestamp: Number(row.ts),
+                value: Number(row.value)
+            };
+        });
+    });
+}
+
+export default function checkpointStatePg(pool, metricsEnabled = true) {
+    return {
+        replayCursor(machineId) {
+            return replayCursor(pool, machineId);
+        },
+        pendingSegments() {
+            return pendingSegments(pool);
+        },
+        readings(topics, from) {
+            if (!metricsEnabled) {
+                return Promise.resolve([]);
+            }
+            return readings(pool, topics, from);
+        },
+        segment(machineId, startEpoch) {
+            return segmentAt(pool, machineId, startEpoch);
+        }
+    };
+}

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

@@ -0,0 +1,73 @@
+export default function metricsStatePg(pool) {
+    return {
+        async latestForTopic(topic) {
+            const result = await pool.query(
+                'SELECT ts, value FROM metrics WHERE topic = $1 ORDER BY ts DESC LIMIT 1',
+                [topic]
+            );
+            return result.rows[0] ?? null;
+        },
+        async rangeForTopic(topic, startIso, endIso, stepMs) {
+            const seconds = Math.max(1, Math.floor(stepMs / 1000));
+            const sql = `SELECT bucket AS ts, value FROM (
+            SELECT date_bin($1::interval, ts, '1970-01-01'::timestamptz) AS bucket, value,
+                   ROW_NUMBER() OVER (PARTITION BY date_bin($1::interval, ts, '1970-01-01'::timestamptz) ORDER BY ts DESC) AS rn
+            FROM metrics WHERE topic = $2 AND ts >= $3 AND ts <= $4
+        ) sub WHERE rn = 1 ORDER BY ts`;
+            const prm = [`${seconds} seconds`, topic, startIso, endIso];
+            const result = await pool.query(sql, prm);
+            return result.rows.map((row) => {
+                return { ts: row.ts, value: row.value };
+            });
+        },
+        async pollTopic(topic, afterIso, untilIso) {
+            const result = await pool.query(
+                'SELECT ts, value FROM metrics WHERE topic = $1 AND ts > $2 AND ts <= $3 ORDER BY ts LIMIT 100',
+                [topic, afterIso, untilIso]
+            );
+            return result.rows.map((row) => {
+                return { ts: row.ts, value: row.value };
+            });
+        },
+        async insertRows(items) {
+            const topics = items.map((row) => {
+                return row.topic;
+            });
+            const tss = items.map((row) => {
+                return row.ts;
+            });
+            const values = items.map((row) => {
+                return row.value;
+            });
+            await pool.query(
+                'INSERT INTO metrics (topic, ts, value) SELECT * FROM unnest($1::text[], $2::timestamptz[], $3::float8[])',
+                [topics, tss, values]
+            );
+        }
+    };
+}
+
+/**
+ * Sink adapter for mqttMetrics writing into supervisor-sink metrics table.
+ *
+ * @param {object} pool - PostgreSQL pool
+ * @returns {object} sink with write(records)
+ */
+export function metricsSinkFromPool(pool) {
+    const metrics = metricsStatePg(pool);
+    return {
+        async write(records) {
+            if (records.length === 0) {
+                return;
+            }
+            const items = records.map((row) => {
+                return {
+                    topic: row.topic,
+                    ts: row.ts instanceof Date ? row.ts : new Date(row.ts),
+                    value: row.value
+                };
+            });
+            await metrics.insertRows(items);
+        }
+    };
+}

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

@@ -0,0 +1,95 @@
+async function upsertOperation(pool, item) {
+    const existing = await pool.query('SELECT 1 FROM operations WHERE key = $1', [item.key]);
+    await pool.query(
+        `INSERT INTO operations (
+            machine, occurred_at, kind, key, payload
+        ) VALUES ($1, $2, $3, $4, $5)
+        ON CONFLICT (key) DO UPDATE SET
+            machine = EXCLUDED.machine,
+            occurred_at = EXCLUDED.occurred_at,
+            kind = EXCLUDED.kind,
+            payload = EXCLUDED.payload`,
+        [
+            item.machine,
+            item.occurred_at,
+            item.kind,
+            item.key,
+            item.payload
+        ]
+    );
+    return { created: existing.rows.length === 0 };
+}
+
+function listForMachine(pool, machineId, kind, range) {
+    let sql = `SELECT machine, occurred_at, kind, key, payload
+        FROM operations WHERE machine = $1 AND kind = $2`;
+    const prm = [machineId, kind];
+    if (range.from) {
+        prm.push(range.from);
+        sql += ` AND occurred_at >= $${prm.length}`;
+    }
+    if (range.to) {
+        prm.push(range.to);
+        sql += ` AND occurred_at <= $${prm.length}`;
+    }
+    sql += ' ORDER BY occurred_at';
+    return pool.query(sql, prm).then((result) => {
+        return result.rows;
+    });
+}
+
+function missing(machineId, key) {
+    return new Error(`operation '${key}' not found for machine '${machineId}'`);
+}
+
+async function getOperation(pool, machineId, key) {
+    const result = await pool.query(
+        `SELECT machine, occurred_at, kind, key, payload
+        FROM operations WHERE machine = $1 AND key = $2`,
+        [machineId, key]
+    );
+    if (result.rows.length === 0) {
+        throw missing(machineId, key);
+    }
+    return result.rows[0];
+}
+
+async function removeOperation(pool, machineId, key) {
+    const result = await pool.query(
+        `DELETE FROM operations WHERE machine = $1 AND key = $2
+        RETURNING machine, occurred_at, kind, key, payload`,
+        [machineId, key]
+    );
+    if (result.rows.length === 0) {
+        throw missing(machineId, key);
+    }
+    return result.rows[0];
+}
+
+/**
+ * PostgreSQL operations persistence port for generic machine operations.
+ *
+ * @param {object} pool - pg pool
+ * @returns {object} operations port with upsert, get, remove, and listForMachine
+ *
+ * @example
+ *   const store = operationStatePg(pool);
+ *   await store.upsert({ machine: 'm1', key: 'nb-1', kind: 'chem', ... });
+ *   await store.remove('m1', 'nb-1');
+ */
+export default function operationStatePg(pool) {
+    return {
+        upsert(item) {
+            return upsertOperation(pool, item);
+        },
+        get(machineId, key) {
+            return getOperation(pool, machineId, key);
+        },
+        remove(machineId, key) {
+            return removeOperation(pool, machineId, key);
+        },
+        listForMachine(machineId, kind, range) {
+            return listForMachine(pool, machineId, kind, range);
+        }
+    };
+}

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

@@ -0,0 +1,118 @@
+import operator from '../../../domain/operator/operator.js';
+
+function conflict(uid) {
+    const err = new Error(`operator cardUid '${uid}' already exists`);
+    err.routeCode = 'CONFLICT';
+    err.routeStatus = 409;
+    return err;
+}
+
+function logFailure(logger, message, err) {
+    if (logger && typeof logger.error === 'function') {
+        logger.error(message, err);
+        return;
+    }
+    console.error(message, err); // eslint-disable-line no-console
+}
+
+async function listRows(pool, logger) {
+    try {
+        const result = await pool.query(
+            'SELECT id, card_uid, first_name, last_name, display_name FROM operators ORDER BY id'
+        );
+        return result.rows.map((row) => {
+            return operator(row.id, row.card_uid, row.first_name, row.last_name, row.display_name);
+        });
+    } catch (err) {
+        const message = `operatorsFromPg list failed: ${err && err.message ? err.message : 'unknown error'}`;
+        logFailure(logger, message, err);
+        throw err;
+    }
+}
+
+async function insertRow(pool, logger, fields) {
+    try {
+        const result = await pool.query(
+            `INSERT INTO operators (card_uid, first_name, last_name, display_name)
+             VALUES ($1, $2, $3, $4)
+             RETURNING id, card_uid, first_name, last_name, display_name`,
+            [fields.cardUid, fields.firstName, fields.lastName, fields.displayName]
+        );
+        const row = result.rows[0];
+        return operator(row.id, row.card_uid, row.first_name, row.last_name, row.display_name);
+    } catch (err) {
+        if (err && err.code === '23505') {
+            throw conflict(fields.cardUid);
+        }
+        const message = `operatorsFromPg create failed: ${err && err.message ? err.message : 'unknown error'}`;
+        logFailure(logger, message, err);
+        throw err;
+    }
+}
+
+async function readFlag(pool, logger) {
+    try {
+        const result = await pool.query(
+            'SELECT enabled FROM operators_registration WHERE singleton = 1'
+        );
+        if (!result.rows.length) {
+            throw new Error('operators_registration singleton row missing');
+        }
+        return result.rows[0].enabled === true;
+    } catch (err) {
+        const message = `operatorsFromPg enabled failed: ${err && err.message ? err.message : 'unknown error'}`;
+        logFailure(logger, message, err);
+        throw err;
+    }
+}
+
+async function writeFlag(pool, logger, flag) {
+    try {
+        const result = await pool.query(
+            `UPDATE operators_registration SET enabled = $1 WHERE singleton = 1
+             RETURNING enabled`,
+            [flag === true]
+        );
+        if (!result.rows.length) {
+            throw new Error('operators_registration singleton row missing');
+        }
+        return result.rows[0].enabled === true;
+    } catch (err) {
+        const message = `operatorsFromPg permit failed: ${err && err.message ? err.message : 'unknown error'}`;
+        logFailure(logger, message, err);
+        throw err;
+    }
+}
+
+/**
+ * PostgreSQL operators port for central site-server.
+ * Implements list(), create(fields), enabled(), and permit(flag).
+ *
+ * @param {object} pool - pg pool
+ * @param {object} [logger] - optional logger with error(message, err)
+ * @returns {object} provider with async list, create, enabled, permit
+ *
+ * @example
+ *   const provider = operatorsFromPg(pool);
+ *   const rows = await provider.list();
+ *   const created = await provider.create({
+ *     cardUid: 'AB12', firstName: 'Ivan', lastName: 'Petrov', displayName: 'Ivan Petrov'
+ *   });
+ *   await provider.permit(true);
+ */
+export default function operatorsFromPg(pool, logger) {
+    return {
+        list() {
+            return listRows(pool, logger);
+        },
+        create(fields) {
+            return insertRow(pool, logger, fields);
+        },
+        enabled() {
+            return readFlag(pool, logger);
+        },
+        permit(flag) {
+            return writeFlag(pool, logger, flag);
+        }
+    };
+}

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

@@ -0,0 +1,48 @@
+export default function segmentStatePg(pool) {
+    return {
+        async listForMachine(machineId, range) {
+            let sql = `SELECT s.name, s.start_time, s.end_time, s.duration, s.options, s.tags, s.properties
+                FROM segments s WHERE s.machine = $1`;
+            const prm = [machineId];
+            if (range.from) {
+                prm.push(range.from);
+                sql += ` AND (s.end_time >= $${prm.length} OR s.duration = 0)`;
+            }
+            if (range.to) {
+                prm.push(range.to);
+                sql += ` AND s.start_time <= $${prm.length}`;
+            }
+            sql += ' ORDER BY s.start_time';
+            const result = await pool.query(sql, prm);
+            return result.rows;
+        },
+        async rowAt(machineId, start) {
+            const result = await pool.query(
+                `SELECT name, start_time, end_time, duration, options, tags, properties
+                 FROM segments WHERE machine = $1 AND start_time = $2`,
+                [machineId, start]
+            );
+            return result.rows[0] ?? null;
+        },
+        async pendingRequestsForMachine(machineId) {
+            const result = await pool.query(
+                `SELECT start_time AS id, name, start_time, end_time, duration, options
+                 FROM segments WHERE machine = $1 AND resolved = FALSE ORDER BY start_time`,
+                [machineId]
+            );
+            return result.rows;
+        },
+        async retag(machineId, start, tagsJson, propertiesJson) {
+            await pool.query(
+                'UPDATE segments SET tags = $1, properties = $2 WHERE machine = $3 AND start_time = $4',
+                [tagsJson, propertiesJson, machineId, start]
+            );
+        },
+        async resolveRequest(machineId, startKey, tagsJson, propertiesJson) {
+            await pool.query(
+                'UPDATE segments SET tags = $1, properties = $2, resolved = TRUE, consumed = FALSE WHERE machine = $3 AND start_time = $4',
+                [tagsJson, propertiesJson, machineId, startKey]
+            );
+        }
+    };
+}

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

@@ -0,0 +1,53 @@
+import segmentStatePg from './segments.js';
+
+function mapRow(item) {
+    const tags = item.tags === undefined || item.tags === null ? null : item.tags;
+    const properties = item.properties === undefined || item.properties === null ? null : item.properties;
+    return {
+        name: item.name,
+        start_time: new Date(item.start_time),
+        end_time: new Date(item.end_time),
+        duration: item.duration,
+        options: item.options,
+        tags,
+        properties
+    };
+}
+
+/**
+ * Postgres-backed timeline read port for one machine.
+ *
+ * @param {object} pool - pg pool
+ * @param {string} machineId - machine identifier
+ * @returns {object} timeline read port with list, rowAt, pending
+ *
+ * @example
+ *   const pg = pgTimeline(pool, 'm1');
+ *   await pg.list({ from: '2024-01-01' });
+ */
+export default function pgTimeline(pool, machineId) {
+    const segments = segmentStatePg(pool);
+    return {
+        async list(range) {
+            const rows = await segments.listForMachine(machineId, range || {});
+            return rows.map(mapRow);
+        },
+        async rowAt(start) {
+            const row = await segments.rowAt(machineId, start);
+            return row ? mapRow(row) : null;
+        },
+        async pending() {
+            const rows = await segments.pendingRequestsForMachine(machineId);
+            return rows.map((item) => {
+                return {
+                    id: item.id,
+                    name: item.name,
+                    start_time: new Date(item.start_time),
+                    end_time: new Date(item.end_time),
+                    duration: item.duration,
+                    options: item.options
+                };
+            });
+        }
+    };
+}