@yarkivaev/scada 1.4.0 → 2.3.45

package/src/meltingMachine.js

@@ -1,53 +0,0 @@
-import machineChronology from './machineChronology.js';
-
-/**
- * Melting machine that tracks metal weight history and sensor measurements.
- * Supports loading and dispensing metal during melting operations.
- * Weight history is tracked for historical queries.
- *
- * @param {string} name - unique machine identifier
- * @param {object} sensors - object containing sensor instances
- * @param {object} alerts - centralized alerts collection
- * @param {number} initial - initial weight (defaults to 0)
- * @returns {object} machine with name, sensors, alerts, chronology, load, dispense
- *
- * @example
- *   const machine = meltingMachine('icht1', { voltage: voltageSensor() }, alerts());
- *   machine.load(500);
- *   machine.chronology().get().weight; // 500
- *   machine.chronology().get(pastDate).weight; // weight at pastDate
- */
-export default function meltingMachine(name, sensors, alerts, initial) {
-    const start = initial === undefined ? 0 : initial;
-    const history = [{ timestamp: new Date(), weight: start }];
-    let current = start;
-    return {
-        name() {
-            return name;
-        },
-        sensors,
-        alerts() {
-            return alerts.all((item) => {
-                return item.object === name;
-            });
-        },
-        chronology() {
-            return machineChronology(start, history, sensors);
-        },
-        load(w) {
-            current += w;
-            history.push({ timestamp: new Date(), weight: current });
-        },
-        dispense(w) {
-            current -= w;
-            history.push({ timestamp: new Date(), weight: current });
-        },
-        reset(w) {
-            current = w;
-            history.push({ timestamp: new Date(), weight: current });
-        },
-        init() {
-            return this;
-        }
-    };
-}

package/src/meltingRuleEngine.js

@@ -1,37 +0,0 @@
-/**
- * Expert system that evaluates measurements and issues alerts.
- * Checks voltage and power factor thresholds.
- *
- * @param {function} issue - callback to issue alerts with message and timestamp
- * @returns {object} rule engine with evaluate method
- *
- * @example
- *   const engine = meltingRuleEngine(function(msg, ts) { console.log(msg); });
- *   engine.evaluate({ voltage: { value: 340 }, cosphi: { value: 0.9 } });
- */
-export default function meltingRuleEngine(issue) {
-    return {
-        evaluate(snapshot) {
-            const timestamp = new Date();
-            const {voltage} = snapshot;
-            const {cosphi} = snapshot;
-            if (voltage && voltage.value < 350) {
-                issue(`Critical low voltage: ${  voltage.value.toFixed(1)  }V`, timestamp);
-            } else if (voltage && voltage.value < 360) {
-                issue(`Low voltage: ${  voltage.value.toFixed(1)  }V`, timestamp);
-            } else if (voltage && voltage.value > 410) {
-                issue(`Critical high voltage: ${  voltage.value.toFixed(1)  }V`, timestamp);
-            } else if (voltage && voltage.value > 400) {
-                issue(`High voltage: ${  voltage.value.toFixed(1)  }V`, timestamp);
-            }
-            if (cosphi && cosphi.value < 0.7) {
-                issue(`Critical low power factor: ${  cosphi.value.toFixed(2)}`, timestamp);
-            } else if (cosphi && cosphi.value < 0.8) {
-                issue(`Low power factor: ${  cosphi.value.toFixed(2)}`, timestamp);
-            }
-            if (voltage && cosphi && voltage.value < 370 && cosphi.value < 0.8) {
-                issue('Power quality issue detected', timestamp);
-            }
-        }
-    };
-}

package/src/meltingShop.js

@@ -1,32 +0,0 @@
-/**
- * Melting shop containing melting machines and their meltings.
- * Provides initialization for all contained machines.
- *
- * @param {string} name - unique identifier for the shop
- * @param {object} meltingMachines - initialized wrapper of melting machines
- * @param {object} meltings - collection managing melting sessions
- * @param {object} alerts - alerts collection for the shop
- * @param {object} events - events collection shared from plant
- * @returns {object} shop with name, machines, meltings, alerts, events properties and init method
- *
- * @example
- *   const shop = meltingShop('shop1', initialized({ m1: machine }, Object.values), meltings(), alerts(), events());
- *   shop.name(); // 'shop1'
- *   shop.machines.init().m1; // access machine by key
- *   shop.events.create(new Date(), {}, ['label']);
- *   shop.init();
- */
-export default function meltingShop(name, meltingMachines, meltings, alerts, events) {
-    return {
-        name() {
-            return name;
-        },
-        machines: meltingMachines,
-        meltings,
-        alerts,
-        events,
-        init() {
-            meltingMachines.init();
-        },
-    };
-}

package/src/meltings.js

@@ -1,97 +0,0 @@
-/* eslint-disable max-lines-per-function, max-statements */
-import pubsub from './pubsub.js';
-import meltingChronology from './meltingChronology.js';
-import activeMelting from './activeMelting.js';
-import completedMelting from './completedMelting.js';
-
-/**
- * Collection of melting sessions associated with machines.
- * Uses add() for creating both active and completed meltings.
- * Uses query() for filtering and streaming meltings.
- *
- * @returns {object} collection with add, query methods
- *
- * @example
- *   const list = meltings();
- *   const active = list.add(machine, {}); // creates active melting
- *   const completed = list.add(machine, { start, end }); // creates completed melting
- *   list.query(); // returns all completed meltings
- *   list.query({ machine }); // returns meltings for machine
- *   list.query({ id: 'm1' }); // returns melting by id
- *   list.query({ stream: callback }); // subscribe to events
- */
-export default function meltings() {
-    const items = [];
-    const bus = pubsub();
-    let counter = 0;
-    function onUpdate(id, updated) {
-        const item = items.find((i) => {
-            return i.melting.id() === id;
-        });
-        if (item) {
-            item.melting = updated;
-            bus.emit({ type: 'updated', melting: updated });
-        }
-    }
-    return {
-        add(machine, data) {
-            const opts = data === undefined ? {} : data;
-            if (opts.end === undefined) {
-                const existing = items.find((i) => {
-                    const chron = i.melting.chronology().get();
-                    return i.machine === machine && chron.end === undefined;
-                });
-                if (existing) {
-                    return existing.melting;
-                }
-            }
-            counter += 1;
-            const id = `m${counter}`;
-            if (opts.end !== undefined) {
-                const chron = meltingChronology(machine, new Date(opts.start), new Date(opts.end));
-                const completed = completedMelting(id, machine, chron, (updated) => {
-                    onUpdate(id, updated);
-                });
-                items.push({ machine, melting: completed });
-                bus.emit({ type: 'completed', melting: completed });
-                return completed;
-            }
-            const start = opts.start === undefined ? new Date() : new Date(opts.start);
-            const item = { machine, melting: undefined };
-            items.push(item);
-            const active = activeMelting(id, machine, start, (completed) => {
-                item.melting = completed;
-                bus.emit({ type: 'completed', melting: completed });
-            }, (updated) => {
-                onUpdate(id, updated);
-            });
-            item.melting = active;
-            bus.emit({ type: 'started', melting: active });
-            return active;
-        },
-        query(options) {
-            const opts = options === undefined ? {} : options;
-            if (opts.stream !== undefined) {
-                return bus.stream(opts.stream);
-            }
-            if (opts.id !== undefined) {
-                const item = items.find((i) => {
-                    return i.melting.id() === opts.id;
-                });
-                return item === undefined ? undefined : item.melting;
-            }
-            if (opts.machine !== undefined) {
-                return items.filter((i) => {
-                    return i.machine === opts.machine;
-                }).map((i) => {
-                    return i.melting;
-                });
-            }
-            return items.filter((i) => {
-                return i.melting.chronology().get().end !== undefined;
-            }).map((i) => {
-                return i.melting;
-            });
-        }
-    };
-}

package/src/monitoredMeltingMachine.js

@@ -1,33 +0,0 @@
-/**
- * Melting machine wrapper that monitors measurements and generates alerts.
- * Periodically evaluates sensor readings using a rule engine via chronology.
- *
- * @param {object} machine - the melting machine to monitor
- * @param {object} ruleEngine - engine that evaluates measurements and triggers alerts
- * @param {function} interval - factory to create periodic intervals
- * @returns {object} monitored machine with name, sensors, alerts, chronology, init methods
- *
- * @example
- *   const monitored = monitoredMeltingMachine(machine, ruleEngine(), interval);
- *   monitored.init(); // starts periodic monitoring
- */
-export default function monitoredMeltingMachine(machine, ruleEngine, interval) {
-    return {
-        name() {
-            return machine.name();
-        },
-        sensors: machine.sensors,
-        alerts() {
-            return machine.alerts();
-        },
-        chronology() {
-            return machine.chronology();
-        },
-        init() {
-            interval(1000, async () => {
-                const snapshot = await machine.chronology().get({ type: 'current' });
-                ruleEngine.evaluate(snapshot);
-            }).start();
-        }
-    };
-}

package/src/plant.js

@@ -1,23 +0,0 @@
-/**
- * Top-level plant structure containing melting shops.
- * Provides initialization for all contained shops.
- *
- * @param {object} shops - initialized list of melting shops
- * @param {object} events - events collection shared by all shops
- * @returns {object} plant with shops, events properties and init method
- *
- * @example
- *   const p = plant(initializedList(shop1, shop2), events(event, rules));
- *   p.shops.list(); // [shop1, shop2]
- *   p.events.create(new Date(), {}, ['label']);
- *   p.init();
- */
-export default function plant(shops, events) {
-    return {
-        shops,
-        events,
-        init() {
-            shops.init();
-        },
-    };
-}

package/src/requests.js

@@ -1,44 +0,0 @@
-import pubsub from './pubsub.js';
-
-/**
- * Per-machine in-memory label request collection.
- * Stores requests for segment labeling with options for the user to choose from.
- * Supports responding to requests and streaming events via pubsub.
- *
- * @returns {object} collection with add, respond, query, stream methods
- *
- * @example
- *   const reqs = requests();
- *   reqs.add({ id: 'req-0', name: 'unknown', startTime: new Date(), endTime: new Date(), duration: 60, options: ['on', 'off'] });
- *   reqs.respond('req-0', { label: 'on' }); // marks resolved
- *   reqs.query(); // returns unresolved requests
- *   const sub = reqs.stream((e) => console.log(e));
- *   sub.cancel();
- */
-export default function requests() {
-    const items = [];
-    const bus = pubsub();
-    return {
-        add(request) {
-            items.push({ ...request, resolved: false });
-            bus.emit({ type: 'created', request });
-        },
-        respond(id, body) {
-            const found = items.find((r) => {
-                return r.id === id && !r.resolved;
-            });
-            if (!found) {
-                return undefined;
-            }
-            found.resolved = true;
-            bus.emit({ type: 'resolved', request: found });
-            return { id, ...body };
-        },
-        query() {
-            return items.filter((r) => {
-                return !r.resolved;
-            });
-        },
-        stream: bus.stream
-    };
-}

package/src/rule.js

@@ -1,33 +0,0 @@
-/**
- * Unified trigger-action mapping for event processing.
- * Evaluates context and executes action when trigger matches.
- *
- * @param {function} trigger - predicate that receives context and returns boolean
- * @param {function} action - callback executed when trigger returns true
- * @returns {object} rule with evaluate method
- *
- * @example
- *   // Sensor rule - executes on voltage threshold
- *   const r1 = rule(
- *       (ctx) => ctx.sensor && ctx.sensor.voltage < 350,
- *       (ctx) => alerts.trigger('Low voltage')
- *   );
- *
- *   // Event rule - handles labeled events
- *   const r2 = rule(
- *       (ctx) => ctx.event && ctx.event.labels().includes('melting-start'),
- *       (ctx) => meltings.add(ctx.event.properties().machine)
- *   );
- *
- *   r1.evaluate({sensor: {voltage: 340}}); // triggers action
- *   r2.evaluate({event: e}); // triggers action if labels match
- */
-export default function rule(trigger, action) {
-    return {
-        evaluate(context) {
-            if (trigger(context)) {
-                action(context);
-            }
-        }
-    };
-}

package/src/rules.js

@@ -1,23 +0,0 @@
-/**
- * Collection of rules with unified evaluation.
- * Evaluates all rules against provided context.
- *
- * @param {object[]} list - array of rule objects with evaluate method
- * @returns {object} rules collection with evaluate and all methods
- *
- * @example
- *   const rs = rules([rule1, rule2, rule3]);
- *   rs.evaluate({sensor: {voltage: 340}}); // evaluates all rules
- *   rs.evaluate({event: e}); // evaluates all rules against event
- *   rs.all(); // returns array of all rules
- */
-export default function rules(list) {
-    return {
-        evaluate(context) {
-            list.forEach((item) => {
-                item.evaluate(context);
-            });
-        },
-        all: () => {return [...list]}
-    };
-}

package/src/scyllaSensor.js

@@ -1,54 +0,0 @@
-/**
- * Sensor backed by ScyllaDB metrics table.
- *
- * Reads sensor measurements from scada.metrics table
- * and provides real-time streaming via polling.
- *
- * @param {object} connection - ScyllaDB connection with query method
- * @param {string} topic - Metric topic in format '{machine}/{sensor}'
- * @param {string} displayName - Human-readable sensor name
- * @param {string} unit - Measurement unit (e.g., 'V', 'cos(φ)')
- * @returns {object} sensor with name, measurements and stream methods
- *
- * @example
- *   const sensor = scyllaSensor(conn, 'icht1/voltage', 'Voltage', 'V');
- *   sensor.name(); // 'Voltage'
- *   await sensor.measurements({ start, end }); // array of readings
- *   sensor.stream(since, 1000, callback); // live stream
- */
-export default function scyllaSensor(connection, topic, displayName, unit) {
-    return {
-        name() {
-            return displayName;
-        },
-        async measurements(range, step) {
-            void step;
-            const rows = await connection.query(
-                'SELECT ts, value FROM scada.metrics WHERE topic = ? AND ts >= ? AND ts <= ?',
-                [topic, range.start, range.end]
-            );
-            return rows.map((row) => {
-                return { timestamp: row.ts, value: row.value, unit };
-            });
-        },
-        stream(since, step, callback, clock) {
-            const time = clock || (() => { return new Date(); });
-            let lastTs = since;
-            const timer = setInterval(async () => {
-                const rows = await connection.query(
-                    'SELECT ts, value FROM scada.metrics WHERE topic = ? AND ts > ? AND ts <= ? LIMIT 100',
-                    [topic, lastTs, time()]
-                );
-                rows.forEach((row) => {
-                    callback({ timestamp: row.ts, value: row.value, unit });
-                    lastTs = row.ts;
-                });
-            }, step);
-            return {
-                cancel() {
-                    clearInterval(timer);
-                }
-            };
-        }
-    };
-}

package/src/segments.js

@@ -1,64 +0,0 @@
-import pubsub from './pubsub.js';
-
-/**
- * Per-machine in-memory timeline segment collection.
- * Stores segments with name, startTime, endTime, duration.
- * Supports resolving by startTime and streaming events via pubsub.
- *
- * @returns {object} collection with add, resolve, query, stream methods
- *
- * @example
- *   const segs = segments();
- *   segs.add({ name: 'on', startTime: new Date(), endTime: new Date(), duration: 60 });
- *   segs.resolve(startTime, ['heating'], {});
- *   segs.query(); // all segments
- *   segs.query({ from: '2024-01-01', to: '2024-01-02' }); // filtered
- *   const sub = segs.stream((e) => console.log(e));
- *   sub.cancel();
- */
-export default function segments() {
-    const items = [];
-    const bus = pubsub();
-    return {
-        add(segment) {
-            items.push(segment);
-            bus.emit({ type: 'created', segment });
-        },
-        resolve(start, tags, properties) {
-            const found = items.find((item) => {
-                return item.startTime.getTime() === start.getTime();
-            });
-            if (found) {
-                found.tags = tags;
-                found.properties = properties;
-                bus.emit({ type: 'resolved', segment: found });
-            }
-        },
-        retag(start, tags, properties) {
-            const found = items.find((item) => {
-                return item.startTime.getTime() === start.getTime();
-            });
-            if (found) {
-                found.tags = tags;
-                found.properties = properties;
-                delete found.options;
-                bus.emit({ type: 'resolved', segment: found });
-            }
-        },
-        query(options) {
-            if (!options) {
-                return items.slice();
-            }
-            return items.filter((item) => {
-                if (options.from && item.endTime < new Date(options.from)) {
-                    return false;
-                }
-                if (options.to && item.startTime > new Date(options.to)) {
-                    return false;
-                }
-                return true;
-            });
-        },
-        stream: bus.stream
-    };
-}

package/src/sqliteSensor.js

@@ -1,106 +0,0 @@
-/**
- * Sensor backed by SQLite metrics table with downsampling.
- *
- * Reads sensor measurements from a SQLite metrics table
- * and provides real-time streaming via polling.
- * Supports time-based downsampling using window functions.
- * Timestamps are stored as epoch milliseconds (REAL).
- *
- * @param {object} connection - SQLite connection with query(sql, params) method
- * @param {string} topic - Metric topic in format '{machine}/{sensor}'
- * @param {string} displayName - Human-readable sensor name
- * @param {string} unit - Measurement unit (e.g., 'V', 'cos(φ)')
- * @returns {object} sensor with name, current, measurements and stream methods
- *
- * @example
- *   const sensor = sqliteSensor(conn, 'icht1/voltage', 'Voltage', 'V');
- *   sensor.name(); // 'Voltage'
- *   await sensor.current(); // { found: true, timestamp, value, unit } or { found: false }
- *   await sensor.measurements({ start, end }, 60000); // downsampled to 1-minute intervals
- *   sensor.stream(since, 1000, callback); // live stream
- */
-// eslint-disable-next-line max-lines-per-function
-export default function sqliteSensor(connection, topic, displayName, unit) {
-    return {
-        /**
-         * Returns the human-readable sensor name.
-         *
-         * @returns {string} Display name
-         */
-        name() {
-            return displayName;
-        },
-        /**
-         * Returns the most recent measurement.
-         *
-         * @returns {Promise<object>} Object with found flag and optional timestamp, value, unit
-         */
-        async current() {
-            const rows = await connection.query(
-                'SELECT ts, value FROM metrics WHERE topic = ? ORDER BY ts DESC LIMIT 1',
-                [topic]
-            );
-            if (rows.length === 0) {
-                return { found: false };
-            }
-            return { found: true, timestamp: new Date(rows[0].ts), value: rows[0].value, unit };
-        },
-        /**
-         * Returns downsampled measurements within a time range.
-         *
-         * @param {object} range - Object with start and end Date properties
-         * @param {number} step - Downsampling bucket size in milliseconds
-         * @returns {Promise<Array>} Array of {timestamp, value, unit} objects
-         */
-        async measurements(range, step) {
-            const millis = Math.max(1000, step);
-            const rows = await connection.query(
-                `SELECT bucket * ? as ts, value FROM (
-                    SELECT CAST(ts / ? AS INTEGER) as bucket, value,
-                           ROW_NUMBER() OVER (PARTITION BY CAST(ts / ? AS INTEGER) ORDER BY ts DESC) as rn
-                    FROM metrics WHERE topic = ? AND ts >= ? AND ts <= ?
-                ) WHERE rn = 1 ORDER BY ts`,
-                [millis, millis, millis, topic, range.start.getTime(), range.end.getTime()]
-            );
-            return rows.map((row) => {
-                return { timestamp: new Date(row.ts), value: row.value, unit };
-            });
-        },
-        /**
-         * Polls for new measurements and delivers them via callback.
-         *
-         * @param {Date} since - Start timestamp for polling
-         * @param {number} step - Polling interval in milliseconds
-         * @param {Function} callback - Called with each {timestamp, value, unit}
-         * @param {Function} [clock] - Optional time provider returning current Date
-         * @returns {object} Object with cancel() method to stop polling
-         */
-        stream(since, step, callback, clock) {
-            const time = clock || (() => { return new Date(); });
-            let lastTs = since;
-            const timer = setInterval(async () => {
-                try {
-                    const rows = await connection.query(
-                        'SELECT ts, value FROM metrics WHERE topic = ? AND ts > ? AND ts <= ? ORDER BY ts LIMIT 100',
-                        [topic, lastTs.getTime(), time().getTime()]
-                    );
-                    rows.forEach((row) => {
-                        const timestamp = new Date(row.ts);
-                        callback({ timestamp, value: row.value, unit });
-                        lastTs = timestamp;
-                    });
-                } catch {
-                    // Connection errors are non-fatal; next poll retries
-                }
-            }, step);
-            return {
-                /**
-                 * Stops the polling timer.
-                 */
-                cancel() {
-                    clearInterval(timer);
-                }
-            };
-        }
-    };
-}