@yarkivaev/scada-server 1.0.0

package/src/server/alertRoute.js

@@ -0,0 +1,96 @@
+import errorResponse from '../objects/errorResponse.js';
+import jsonResponse from '../objects/jsonResponse.js';
+import pagination from '../objects/pagination.js';
+import route from '../objects/route.js';
+
+/**
+ * Alert routes factory.
+ * Creates routes for GET and PATCH /machines/:machineId/alerts.
+ *
+ * @param {string} basePath - base URL path
+ * @param {object} plant - plant domain object from scada package
+ * @returns {array} array of route objects
+ *
+ * @example
+ *   const routes = alertRoute('/api/v1', plant);
+ */
+export default function alertRoute(basePath, plant) {
+    function find(id) {
+        for (const shop of Object.values(plant.shops.get())) {
+            const machine = shop.machines.get()[id];
+            if (machine) {
+                return machine;
+            }
+        }
+        return undefined;
+    }
+    function findAlert(alertId) {
+        for (const shop of Object.values(plant.shops.get())) {
+            for (const machine of Object.values(shop.machines.get())) {
+                const alert = machine.alerts().find((a) => {
+                    return a.id === alertId;
+                });
+                if (alert) {
+                    return alert;
+                }
+            }
+        }
+        return undefined;
+    }
+    return [
+        route(
+            'GET',
+            `${basePath}/machines/:machineId/alerts`,
+            (req, res, params, query) => {
+                const machine = find(params.machineId);
+                if (!machine) {
+                    jsonResponse({ items: [], page: 1, size: 10, total: 0 }).send(res);
+                    return;
+                }
+                const page = query.page ? parseInt(query.page, 10) : 1;
+                const size = query.size ? parseInt(query.size, 10) : 10;
+                let alerts = machine.alerts();
+                if (query.acknowledged === 'true') {
+                    alerts = alerts.filter((a) => {
+                        return a.acknowledged === true;
+                    });
+                } else if (query.acknowledged === 'false') {
+                    alerts = alerts.filter((a) => {
+                        return a.acknowledged === false;
+                    });
+                }
+                const mapped = alerts.map((a) => {
+                    return { id: a.id, message: a.message, timestamp: a.timestamp.toISOString(), object: a.object, acknowledged: a.acknowledged };
+                });
+                const paginated = pagination(page, size, mapped).result();
+                jsonResponse({ items: paginated.items, page: paginated.page, size: paginated.size, total: paginated.total }).send(res);
+            }
+        ),
+        route(
+            'PATCH',
+            `${basePath}/machines/:machineId/alerts/:alertId`,
+            (req, res, params) => {
+                let body = '';
+                req.on('data', (chunk) => {
+                    body += chunk;
+                });
+                req.on('end', () => {
+                    const changes = JSON.parse(body);
+                    const alert = findAlert(params.alertId);
+                    if (!alert) {
+                        errorResponse(
+                            'NOT_FOUND',
+                            `Alert '${params.alertId}' not found`,
+                            404
+                        ).send(res);
+                        return;
+                    }
+                    if (changes.acknowledged === true && !alert.acknowledged) {
+                        alert.acknowledge();
+                    }
+                    jsonResponse({ id: alert.id, message: alert.message, timestamp: alert.timestamp.toISOString(), object: alert.object, acknowledged: true }).send(res);
+                });
+            }
+        )
+    ];
+}

package/src/server/alertStream.js

@@ -0,0 +1,68 @@
+import route from '../objects/route.js';
+import sseResponse from '../objects/sseResponse.js';
+
+/**
+ * Alert stream route factory.
+ * Creates SSE route for /machines/:machineId/alerts/stream.
+ * Streams alert_created and alert_updated events for the specified machine.
+ *
+ * @param {string} basePath - base URL path
+ * @param {object} plant - plant domain object from scada package
+ * @param {function} clock - time provider
+ * @returns {array} array of route objects
+ *
+ * @example
+ *   const routes = alertStream('/api/v1', plant, clock);
+ */
+export default function alertStream(basePath, plant, clock) {
+    function find(machineId) {
+        for (const shop of Object.values(plant.shops.get())) {
+            const machine = shop.machines.get()[machineId];
+            if (machine) {
+                return { machine, shop };
+            }
+        }
+        return undefined;
+    }
+    return [
+        route(
+            'GET',
+            `${basePath}/machines/:machineId/alerts/stream`,
+            (req, res, params) => {
+                const sse = sseResponse(res, clock);
+                sse.heartbeat();
+                const result = find(params.machineId);
+                if (!result) {
+                    sse.close();
+                    return;
+                }
+                const { machine, shop } = result;
+                const subscription = shop.alerts.stream((event) => {
+                    if (event.alert.object === machine.name()) {
+                        if (event.type === 'created') {
+                            sse.emit('alert_created', {
+                                id: event.alert.id,
+                                message: event.alert.message,
+                                timestamp: event.alert.timestamp.toISOString(),
+                                object: event.alert.object,
+                                acknowledged: event.alert.acknowledged
+                            });
+                        } else if (event.type === 'acknowledged') {
+                            sse.emit('alert_updated', {
+                                id: event.alert.id,
+                                acknowledged: true
+                            });
+                        }
+                    }
+                });
+                const heartbeat = setInterval(() => {
+                    sse.heartbeat();
+                }, 30000);
+                req.on('close', () => {
+                    clearInterval(heartbeat);
+                    subscription.cancel();
+                });
+            }
+        )
+    ];
+}

package/src/server/machineRoute.js

@@ -0,0 +1,115 @@
+import errorResponse from '../objects/errorResponse.js';
+import jsonResponse from '../objects/jsonResponse.js';
+import route from '../objects/route.js';
+
+/**
+ * Machine routes factory.
+ * Creates routes for GET /machines and GET /machines/:machineId.
+ *
+ * @param {string} basePath - base URL path
+ * @param {object} plant - plant domain object from scada package
+ * @returns {array} array of route objects
+ *
+ * @example
+ *   const routes = machineRoute('/api/v1', plant);
+ */
+export default function machineRoute(basePath, plant) {
+    function all() {
+        return Object.values(plant.shops.get()).flatMap((shop) => {
+            return Object.values(shop.machines.get()).map((machine) => {
+                return { id: machine.name(), name: machine.name() };
+            });
+        });
+    }
+    function find(id) {
+        for (const shop of Object.values(plant.shops.get())) {
+            const machine = shop.machines.get()[id];
+            if (machine) {
+                return { id: machine.name(), name: machine.name() };
+            }
+        }
+        return undefined;
+    }
+    function findMachine(id) {
+        for (const shop of Object.values(plant.shops.get())) {
+            const machine = shop.machines.get()[id];
+            if (machine) {
+                return machine;
+            }
+        }
+        return undefined;
+    }
+    return [
+        route('GET', `${basePath}/machines`, (req, res) => {
+            jsonResponse({ items: all() }).send(res);
+        }),
+        route('GET', `${basePath}/machines/:machineId`, (req, res, params) => {
+            const machine = find(params.machineId);
+            if (!machine) {
+                errorResponse(
+                    'NOT_FOUND',
+                    `Machine '${params.machineId}' not found`,
+                    404
+                ).send(res);
+                return;
+            }
+            jsonResponse(machine).send(res);
+        }),
+        route('GET', `${basePath}/machines/:machineId/weight`, (req, res, params) => {
+            const machine = findMachine(params.machineId);
+            if (!machine) {
+                errorResponse('NOT_FOUND', `Machine '${params.machineId}' not found`, 404).send(res);
+                return;
+            }
+            jsonResponse({ amount: machine.chronology().get({ type: 'current' }).weight }).send(res);
+        }),
+        route('PUT', `${basePath}/machines/:machineId/weight`, (req, res, params) => {
+            const machine = findMachine(params.machineId);
+            if (!machine) {
+                errorResponse('NOT_FOUND', `Machine '${params.machineId}' not found`, 404).send(res);
+                return;
+            }
+            let body = '';
+            req.on('data', (chunk) => {
+                body += chunk;
+            });
+            req.on('end', () => {
+                const data = JSON.parse(body);
+                machine.reset(data.amount);
+                jsonResponse({ amount: machine.chronology().get({ type: 'current' }).weight }).send(res);
+            });
+        }),
+        route('POST', `${basePath}/machines/:machineId/load`, (req, res, params) => {
+            const machine = findMachine(params.machineId);
+            if (!machine) {
+                errorResponse('NOT_FOUND', `Machine '${params.machineId}' not found`, 404).send(res);
+                return;
+            }
+            let body = '';
+            req.on('data', (chunk) => {
+                body += chunk;
+            });
+            req.on('end', () => {
+                const data = JSON.parse(body);
+                machine.load(data.amount);
+                jsonResponse({ amount: data.amount }).send(res);
+            });
+        }),
+        route('POST', `${basePath}/machines/:machineId/dispense`, (req, res, params) => {
+            const machine = findMachine(params.machineId);
+            if (!machine) {
+                errorResponse('NOT_FOUND', `Machine '${params.machineId}' not found`, 404).send(res);
+                return;
+            }
+            let body = '';
+            req.on('data', (chunk) => {
+                body += chunk;
+            });
+            req.on('end', () => {
+                const data = JSON.parse(body);
+                machine.dispense(data.amount);
+                jsonResponse({ amount: data.amount }).send(res);
+            });
+        })
+    ];
+}

package/src/server/measurementRoute.js

@@ -0,0 +1,63 @@
+import jsonResponse from '../objects/jsonResponse.js';
+import route from '../objects/route.js';
+import timeExpression from '../objects/timeExpression.js';
+
+/**
+ * Measurement routes factory.
+ * Creates route for GET /machines/:machineId/measurements.
+ *
+ * @param {string} basePath - base URL path
+ * @param {object} plant - plant domain object from scada package
+ * @param {function} clock - time provider
+ * @returns {array} array of route objects
+ *
+ * @example
+ *   const routes = measurementRoute('/api/v1', plant, clock);
+ */
+export default function measurementRoute(basePath, plant, clock) {
+    function beginning() {
+        return new Date(clock().getTime() - 30 * 24 * 60 * 60 * 1000);
+    }
+    function find(id) {
+        for (const shop of Object.values(plant.shops.get())) {
+            const machine = shop.machines.get()[id];
+            if (machine) {
+                return machine;
+            }
+        }
+        return undefined;
+    }
+    return [
+        route(
+            'GET',
+            `${basePath}/machines/:machineId/measurements`,
+            async (req, res, params, query) => {
+                const machine = find(params.machineId);
+                if (!machine) {
+                    jsonResponse({ items: [] }).send(res);
+                    return;
+                }
+                const requested = query.keys ? query.keys.split(',') : Object.keys(machine.sensors);
+                const keys = requested.filter((key) => {return machine.sensors[key]});
+                const fromExpr = query.from || 'now-1M';
+                const toExpr = query.to || 'now';
+                const from = timeExpression(fromExpr, clock, beginning).resolve();
+                const to = timeExpression(toExpr, clock, beginning).resolve();
+                const step = query.step ? parseInt(query.step, 10) * 1000 : 1000;
+                const range = { start: from, end: to };
+                const promises = keys.map(async (key) => {
+                    const sensor = machine.sensors[key];
+                    const measurements = await sensor.measurements(range, step);
+                    const unit = measurements.length > 0 ? measurements[0].unit : '';
+                    const values = measurements.map((m) => {return {
+                        timestamp: m.timestamp.toISOString(),
+                        value: m.value
+                    }});
+                    return { key, name: sensor.name(), unit, values };
+                });
+                const items = await Promise.all(promises);
+                jsonResponse({ items }).send(res);
+            }
+        )
+    ];
+}

package/src/server/measurementStream.js

@@ -0,0 +1,71 @@
+import route from '../objects/route.js';
+import sseResponse from '../objects/sseResponse.js';
+import timeExpression from '../objects/timeExpression.js';
+
+/**
+ * Measurement stream route factory.
+ * Creates SSE route for /machines/:machineId/measurements/stream.
+ *
+ * @param {string} basePath - base URL path
+ * @param {object} plant - plant domain object from scada package
+ * @param {function} clock - time provider
+ * @returns {array} array of route objects
+ *
+ * @example
+ *   const routes = measurementStream('/api/v1', plant, clock);
+ */
+export default function measurementStream(basePath, plant, clock) {
+    function beginning() {
+        return new Date(clock().getTime() - 30 * 24 * 60 * 60 * 1000);
+    }
+    function find(id) {
+        for (const shop of Object.values(plant.shops.get())) {
+            const machine = shop.machines.get()[id];
+            if (machine) {
+                return machine;
+            }
+        }
+        return undefined;
+    }
+    return [
+        route(
+            'GET',
+            `${basePath}/machines/:machineId/measurements/stream`,
+            (req, res, params, query) => {
+                const sse = sseResponse(res, clock);
+                sse.heartbeat();
+                const machine = find(params.machineId);
+                if (!machine) {
+                    sse.close();
+                    return;
+                }
+                const keys = query.keys ? query.keys.split(',') : Object.keys(machine.sensors);
+                const sinceExpr = query.since || 'now';
+                const since = timeExpression(sinceExpr, clock, beginning).resolve();
+                const step = query.step ? parseInt(query.step, 10) * 1000 : 1000;
+                const subscriptions = [];
+                keys.forEach((key) => {
+                    if (machine.sensors[key]) {
+                        const subscription = machine.sensors[key].stream(since, step, (item) => {
+                            sse.emit('measurement', {
+                                key,
+                                timestamp: item.timestamp.toISOString(),
+                                value: item.value
+                            });
+                        });
+                        subscriptions.push(subscription);
+                    }
+                });
+                const heartbeat = setInterval(() => {
+                    sse.heartbeat();
+                }, 30000);
+                req.on('close', () => {
+                    clearInterval(heartbeat);
+                    subscriptions.forEach((subscription) => {
+                        subscription.cancel();
+                    });
+                });
+            }
+        )
+    ];
+}

package/src/server/meltingRoute.js

@@ -0,0 +1,175 @@
+import cursor from '../objects/cursor.js';
+import errorResponse from '../objects/errorResponse.js';
+import jsonResponse from '../objects/jsonResponse.js';
+import route from '../objects/route.js';
+
+/**
+ * Converts melting domain object to API response format.
+ *
+ * @param {object} melting - melting domain object
+ * @returns {object} API response object
+ */
+function format(melting) {
+    const data = melting.chronology().get();
+    const result = {
+        id: melting.id(),
+        start: data.start.toISOString(),
+        initial: data.initial,
+        weight: data.weight,
+        loaded: data.loaded,
+        dispensed: data.dispensed
+    };
+    if (data.end) {
+        result.end = data.end.toISOString();
+    }
+    return result;
+}
+
+/**
+ * Melting read routes factory.
+ * Creates routes for GET /machines/:machineId/meltings.
+ *
+ * @param {string} basePath - base URL path
+ * @param {function} findMachine - function to find machine by ID
+ * @returns {array} array of route objects
+ */
+function readRoutes(basePath, findMachine) {
+    return [
+        route('GET', `${basePath}/machines/:machineId/meltings`, (req, res, params, query) => {
+            const result = findMachine(params.machineId);
+            if (!result) {
+                jsonResponse({ items: [], hasMore: false }).send(res);
+                return;
+            }
+            const { machine, shop } = result;
+            const {after} = query;
+            const {before} = query;
+            const limit = query.limit ? parseInt(query.limit, 10) : 10;
+            const active = query.active === 'true';
+            const meltings = shop.meltings.query({ machine }).map(format).sort((a, b) => {
+                return new Date(b.start).getTime() - new Date(a.start).getTime();
+            });
+            const paginated = cursor(after, before, limit, meltings, active).result();
+            jsonResponse({ items: paginated.items, nextCursor: paginated.nextCursor, hasMore: paginated.hasMore }).send(res);
+        }),
+        route('GET', `${basePath}/machines/:machineId/meltings/:meltingId`, (req, res, params) => {
+            const result = findMachine(params.machineId);
+            if (!result) {
+                errorResponse('NOT_FOUND', `Melting '${params.meltingId}' not found`, 404).send(res);
+                return;
+            }
+            const { machine, shop } = result;
+            const melting = shop.meltings.query({ machine }).find((m) => {
+                return m.id() === params.meltingId;
+            });
+            if (!melting) {
+                errorResponse('NOT_FOUND', `Melting '${params.meltingId}' not found`, 404).send(res);
+                return;
+            }
+            jsonResponse(format(melting)).send(res);
+        })
+    ];
+}
+
+/**
+ * Melting write routes factory.
+ * Creates routes for POST/PUT /machines/:machineId/meltings.
+ *
+ * @param {string} basePath - base URL path
+ * @param {function} findMachine - function to find machine by ID
+ * @returns {array} array of route objects
+ */
+function writeRoutes(basePath, findMachine) {
+    return [
+        route('POST', `${basePath}/machines/:machineId/meltings/start`, (req, res, params) => {
+            const result = findMachine(params.machineId);
+            if (!result) {
+                errorResponse('NOT_FOUND', `Machine '${params.machineId}' not found`, 404).send(res);
+                return;
+            }
+            const { machine, shop } = result;
+            const active = shop.meltings.add(machine, {});
+            res.writeHead(201, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(format(active)));
+        }),
+        route('POST', `${basePath}/machines/:machineId/meltings/:meltingId/stop`, (req, res, params) => {
+            const result = findMachine(params.machineId);
+            if (!result) {
+                errorResponse('NOT_FOUND', `Active melting '${params.meltingId}' not found`, 404).send(res);
+                return;
+            }
+            const { shop } = result;
+            const melting = shop.meltings.query({ id: params.meltingId });
+            if (!melting || !melting.stop) {
+                errorResponse('NOT_FOUND', `Active melting '${params.meltingId}' not found`, 404).send(res);
+                return;
+            }
+            const completed = melting.stop();
+            jsonResponse(format(completed)).send(res);
+        }),
+        route('POST', `${basePath}/machines/:machineId/meltings`, (req, res, params) => {
+            const result = findMachine(params.machineId);
+            if (!result) {
+                errorResponse('NOT_FOUND', `Machine '${params.machineId}' not found`, 404).send(res);
+                return;
+            }
+            let body = '';
+            req.on('data', (chunk) => {
+                body += chunk;
+            });
+            req.on('end', () => {
+                const data = JSON.parse(body);
+                const { machine, shop } = result;
+                const melting = shop.meltings.add(machine, data);
+                res.writeHead(201, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(format(melting)));
+            });
+        }),
+        route('PUT', `${basePath}/machines/:machineId/meltings/:meltingId`, (req, res, params) => {
+            const result = findMachine(params.machineId);
+            if (!result) {
+                errorResponse('NOT_FOUND', `Melting '${params.meltingId}' not found`, 404).send(res);
+                return;
+            }
+            let body = '';
+            req.on('data', (chunk) => {
+                body += chunk;
+            });
+            req.on('end', () => {
+                const data = JSON.parse(body);
+                const { shop } = result;
+                const melting = shop.meltings.query({ id: params.meltingId });
+                if (!melting) {
+                    errorResponse('NOT_FOUND', `Melting '${params.meltingId}' not found`, 404).send(res);
+                    return;
+                }
+                const updated = melting.update(data);
+                jsonResponse(format(updated)).send(res);
+            });
+        })
+    ];
+}
+
+/**
+ * Melting routes factory.
+ * Creates routes for /machines/:machineId/meltings.
+ *
+ * @param {string} basePath - base URL path
+ * @param {object} plant - plant domain object from scada package
+ * @returns {array} array of route objects
+ *
+ * @example
+ *   const routes = meltingRoute('/api/v1', plant);
+ */
+export default function meltingRoute(basePath, plant) {
+    function findMachine(id) {
+        for (const shop of Object.values(plant.shops.get())) {
+            const machine = shop.machines.get()[id];
+            if (machine) {
+                return { machine, shop };
+            }
+        }
+        return undefined;
+    }
+    return [...readRoutes(basePath, findMachine), ...writeRoutes(basePath, findMachine)];
+}

package/src/server/meltingStream.js

@@ -0,0 +1,70 @@
+import route from '../objects/route.js';
+import sseResponse from '../objects/sseResponse.js';
+
+/**
+ * Melting stream route factory.
+ * Creates SSE route for /machines/:machineId/meltings/stream.
+ *
+ * @param {string} basePath - base URL path
+ * @param {object} plant - plant domain object from scada package
+ * @param {function} clock - time provider
+ * @returns {array} array of route objects
+ *
+ * @example
+ *   const routes = meltingStream('/api/v1', plant, clock);
+ */
+export default function meltingStream(basePath, plant, clock) {
+    function findMachine(id) {
+        for (const shop of Object.values(plant.shops.get())) {
+            const machine = shop.machines.get()[id];
+            if (machine) {
+                return { machine, shop };
+            }
+        }
+        return undefined;
+    }
+    return [
+        route(
+            'GET',
+            `${basePath}/machines/:machineId/meltings/stream`,
+            (req, res, params) => {
+                const sse = sseResponse(res, clock);
+                sse.heartbeat();
+                const result = findMachine(params.machineId);
+                if (!result) {
+                    sse.close();
+                    return;
+                }
+                const { machine, shop } = result;
+                const subscription = shop.meltings.query({ stream: (event) => {
+                    if (event.type === 'started') {
+                        const m = event.melting;
+                        const data = m.chronology().get();
+                        sse.emit('melting_started', {
+                            id: m.id(),
+                            start: data.start.toISOString()
+                        });
+                    } else if (event.type === 'completed') {
+                        const m = event.melting;
+                        const data = m.chronology().get();
+                        sse.emit('melting_ended', {
+                            id: m.id(),
+                            end: data.end.toISOString(),
+                            initial: data.initial,
+                            weight: data.weight,
+                            loaded: data.loaded,
+                            dispensed: data.dispensed
+                        });
+                    }
+                }});
+                const heartbeat = setInterval(() => {
+                    sse.heartbeat();
+                }, 30000);
+                req.on('close', () => {
+                    clearInterval(heartbeat);
+                    subscription.cancel();
+                });
+            }
+        )
+    ];
+}