@yarkivaev/scada-server 1.0.1 → 1.1.1

package/client/machineClient.js

@@ -1,5 +1,20 @@
 import sseConnection from './sseConnection.js';
 
+/**
+ * Builds a JSON request payload with method, headers, and body.
+ *
+ * @param {string} method - HTTP method
+ * @param {object} data - request body data
+ * @returns {object} fetch options with method, headers, and stringified body
+ */
+function payload(method, data) {
+    return {
+        method,
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(data)
+    };
+}
+
 /**
  * Client for single machine endpoints.
  * Returns object with methods for machine operations.
@@ -18,11 +33,11 @@ export default function machineClient(baseUrl, machineId, fetcher, eventSource)
     const url = `${baseUrl}/machines/${machineId}`;
     async function request(path, options) {
         const response = await fetcher(`${url}${path}`, options);
-        const payload = await response.json();
+        const result = await response.json();
         if (!response.ok) {
-            throw payload;
+            throw result;
         }
-        return payload;
+        return result;
     }
     return {
         async info() {
@@ -80,11 +95,7 @@ export default function machineClient(baseUrl, machineId, fetcher, eventSource)
             return sseConnection(`${url}/alerts/stream`, eventSource);
         },
         async acknowledge(alertId) {
-            return request(`/alerts/${alertId}`, {
-                method: 'PATCH',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ acknowledged: true })
-            });
+            return request(`/alerts/${alertId}`, payload('PATCH', { acknowledged: true }));
         },
         async meltings(options) {
             const params = new URLSearchParams();
@@ -109,6 +120,29 @@ export default function machineClient(baseUrl, machineId, fetcher, eventSource)
         meltingStream() {
             return sseConnection(`${url}/meltings/stream`, eventSource);
         },
+        async segments(options) {
+            const params = new URLSearchParams();
+            if (options && options.from) {
+                params.set('from', options.from);
+            }
+            if (options && options.to) {
+                params.set('to', options.to);
+            }
+            const qs = params.toString();
+            return request(`/segments${qs ? `?${qs}` : ''}`);
+        },
+        segmentStream() {
+            return sseConnection(`${url}/segments/stream`, eventSource);
+        },
+        async requests() {
+            return request('/requests');
+        },
+        requestStream() {
+            return sseConnection(`${url}/requests/stream`, eventSource);
+        },
+        async respond(requestId, data) {
+            return request(`/requests/${requestId}/respond`, payload('POST', data));
+        },
         async startMelting() {
             return request('/meltings/start', { method: 'POST' });
         },
@@ -119,25 +153,13 @@ export default function machineClient(baseUrl, machineId, fetcher, eventSource)
             return request('/weight');
         },
         async setWeight(amount) {
-            return request('/weight', {
-                method: 'PUT',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ amount })
-            });
+            return request('/weight', payload('PUT', { amount }));
         },
         async load(amount) {
-            return request('/load', {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ amount })
-            });
+            return request('/load', payload('POST', { amount }));
         },
         async dispense(amount) {
-            return request('/dispense', {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ amount })
-            });
+            return request('/dispense', payload('POST', { amount }));
         }
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yarkivaev/scada-server",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "Composable SCADA server implementing Supervisor API",
   "repository": {
     "type": "git",
@@ -8,6 +8,10 @@
   },
   "type": "module",
   "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client/index.js"
+  },
   "scripts": {
     "test": "mocha --exit 'test/unit/**/*.js'",
     "test:integration": "mocha --exit 'test/integration/**/*.js'",
@@ -19,6 +23,7 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
+    "@yarkivaev/scada": "^1.2.0",
     "c8": "^10.1.3",
     "eslint": "^9.39.2",
     "globals": "^17.0.0",

package/src/server/machineRoute.js

@@ -55,13 +55,13 @@ export default function machineRoute(basePath, plant) {
             }
             jsonResponse(machine).send(res);
         }),
-        route('GET', `${basePath}/machines/:machineId/weight`, (req, res, params) => {
+        route('GET', `${basePath}/machines/:machineId/weight`, async (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);
+            jsonResponse({ amount: (await machine.chronology().get({ type: 'current' })).weight }).send(res);
         }),
         route('PUT', `${basePath}/machines/:machineId/weight`, (req, res, params) => {
             const machine = findMachine(params.machineId);
@@ -73,10 +73,10 @@ export default function machineRoute(basePath, plant) {
             req.on('data', (chunk) => {
                 body += chunk;
             });
-            req.on('end', () => {
+            req.on('end', async () => {
                 const data = JSON.parse(body);
                 machine.reset(data.amount);
-                jsonResponse({ amount: machine.chronology().get({ type: 'current' }).weight }).send(res);
+                jsonResponse({ amount: (await machine.chronology().get({ type: 'current' })).weight }).send(res);
             });
         }),
         route('POST', `${basePath}/machines/:machineId/load`, (req, res, params) => {

package/src/server/requestRoute.js

@@ -0,0 +1,86 @@
+import errorResponse from '../objects/errorResponse.js';
+import jsonResponse from '../objects/jsonResponse.js';
+import route from '../objects/route.js';
+
+/**
+ * Label request routes factory.
+ * Creates routes for GET and POST /machines/:machineId/requests.
+ *
+ * @param {string} basePath - base URL path
+ * @param {object} plant - plant domain object from scada package
+ * @returns {array} array of route objects
+ *
+ * @example
+ *   const routes = requestRoute('/api/v1', plant);
+ */
+export default function requestRoute(basePath, plant) {
+    function find(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/requests`,
+            async (req, res, params) => {
+                const result = find(params.machineId);
+                if (!result) {
+                    jsonResponse({ items: [] }).send(res);
+                    return;
+                }
+                const { machine } = result;
+                const requests = await machine.requests.query();
+                const items = requests.map((item) => {
+                    return {
+                        id: item.id,
+                        segment: {
+                            name: item.name,
+                            start: item.startTime.toISOString(),
+                            end: item.endTime.toISOString(),
+                            duration: item.duration
+                        },
+                        options: item.options
+                    };
+                });
+                jsonResponse({ items }).send(res);
+            }
+        ),
+        route(
+            'POST',
+            `${basePath}/machines/:machineId/requests/:requestId/respond`,
+            (req, res, params) => {
+                let body = '';
+                req.on('data', (chunk) => {
+                    body += chunk;
+                });
+                req.on('end', async () => {
+                    const result = find(params.machineId);
+                    if (!result) {
+                        errorResponse(
+                            'NOT_FOUND',
+                            `Machine '${params.machineId}' not found`,
+                            404
+                        ).send(res);
+                        return;
+                    }
+                    const { machine } = result;
+                    const response = await machine.requests.respond(params.requestId, JSON.parse(body));
+                    if (!response) {
+                        errorResponse(
+                            'NOT_FOUND',
+                            `Request '${params.requestId}' not found`,
+                            404
+                        ).send(res);
+                        return;
+                    }
+                    jsonResponse({ id: params.requestId, status: 'resolved' }).send(res);
+                });
+            }
+        )
+    ];
+}

package/src/server/requestStream.js

@@ -0,0 +1,68 @@
+import route from '../objects/route.js';
+import sseResponse from '../objects/sseResponse.js';
+
+/**
+ * Request stream route factory.
+ * Creates SSE route for /machines/:machineId/requests/stream.
+ * Streams request_created and request_resolved 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 = requestStream('/api/v1', plant, clock);
+ */
+export default function requestStream(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/requests/stream`,
+            (req, res, params) => {
+                const sse = sseResponse(res, clock);
+                sse.heartbeat();
+                const result = find(params.machineId);
+                if (!result) {
+                    sse.close();
+                    return;
+                }
+                const { machine } = result;
+                const subscription = machine.requests.stream((event) => {
+                    if (event.type === 'created') {
+                        sse.emit('request_created', {
+                            id: event.request.id,
+                            segment: {
+                                name: event.request.name,
+                                start: event.request.startTime.toISOString(),
+                                end: event.request.endTime.toISOString(),
+                                duration: event.request.duration
+                            },
+                            options: event.request.options
+                        });
+                    } else if (event.type === 'resolved') {
+                        sse.emit('request_resolved', {
+                            id: event.request.id
+                        });
+                    }
+                });
+                const heartbeat = setInterval(() => {
+                    sse.heartbeat();
+                }, 30000);
+                req.on('close', () => {
+                    clearInterval(heartbeat);
+                    subscription.cancel();
+                });
+            }
+        )
+    ];
+}

package/src/server/scadaServer.js

@@ -5,6 +5,10 @@ import measurementRoute from './measurementRoute.js';
 import measurementStream from './measurementStream.js';
 import meltingRoute from './meltingRoute.js';
 import meltingStream from './meltingStream.js';
+import segmentRoute from './segmentRoute.js';
+import segmentStream from './segmentStream.js';
+import requestRoute from './requestRoute.js';
+import requestStream from './requestStream.js';
 import routes from './routes.js';
 
 /**
@@ -35,7 +39,11 @@ export default function scadaServer(basePath, plant, clock) {
         ...alertStream(basePath, plant, time),
         ...alertRoute(basePath, plant),
         ...meltingStream(basePath, plant, time),
-        ...meltingRoute(basePath, plant)
+        ...meltingRoute(basePath, plant),
+        ...segmentRoute(basePath, plant),
+        ...segmentStream(basePath, plant, time),
+        ...requestRoute(basePath, plant),
+        ...requestStream(basePath, plant, time)
     ];
     return routes(routeList);
 }

package/src/server/segmentRoute.js

@@ -0,0 +1,63 @@
+import jsonResponse from '../objects/jsonResponse.js';
+import route from '../objects/route.js';
+
+/**
+ * Segment routes factory.
+ * Creates route for GET /machines/:machineId/segments.
+ *
+ * @param {string} basePath - base URL path
+ * @param {object} plant - plant domain object from scada package
+ * @returns {array} array of route objects
+ *
+ * @example
+ *   const routes = segmentRoute('/api/v1', plant);
+ */
+export default function segmentRoute(basePath, plant) {
+    function find(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/segments`,
+            async (req, res, params, query) => {
+                const result = find(params.machineId);
+                if (!result) {
+                    jsonResponse({ items: [] }).send(res);
+                    return;
+                }
+                const { machine } = result;
+                const options = {};
+                if (query.from) {
+                    options.from = query.from;
+                }
+                if (query.to) {
+                    options.to = query.to;
+                }
+                const segments = await machine.segments.query(options);
+                const items = segments.map((s) => {
+                    const mapped = {
+                        name: s.name,
+                        start: s.startTime.toISOString(),
+                        end: s.duration === 0 ? new Date().toISOString() : s.endTime.toISOString(),
+                        duration: s.duration
+                    };
+                    if (s.options) {
+                        mapped.options = s.options;
+                    }
+                    if (s.label) {
+                        mapped.label = s.label;
+                    }
+                    return mapped;
+                });
+                jsonResponse({ items }).send(res);
+            }
+        )
+    ];
+}

package/src/server/segmentStream.js

@@ -0,0 +1,67 @@
+import route from '../objects/route.js';
+import sseResponse from '../objects/sseResponse.js';
+
+/**
+ * Segment stream route factory.
+ * Creates SSE route for /machines/:machineId/segments/stream.
+ * Streams segment_created and segment_relabeled 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 = segmentStream('/api/v1', plant, clock);
+ */
+export default function segmentStream(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/segments/stream`,
+            (req, res, params) => {
+                const sse = sseResponse(res, clock);
+                sse.heartbeat();
+                const result = find(params.machineId);
+                if (!result) {
+                    sse.close();
+                    return;
+                }
+                const { machine } = result;
+                const subscription = machine.segments.stream((event) => {
+                    if (event.type === 'created') {
+                        sse.emit('segment_created', {
+                            name: event.segment.name,
+                            start: event.segment.startTime.toISOString(),
+                            end: event.segment.endTime.toISOString(),
+                            duration: event.segment.duration
+                        });
+                    } else if (event.type === 'relabeled') {
+                        sse.emit('segment_relabeled', {
+                            name: event.segment.name,
+                            start: event.segment.startTime.toISOString(),
+                            end: event.segment.endTime.toISOString(),
+                            duration: event.segment.duration
+                        });
+                    }
+                });
+                const heartbeat = setInterval(() => {
+                    sse.heartbeat();
+                }, 30000);
+                req.on('close', () => {
+                    clearInterval(heartbeat);
+                    subscription.cancel();
+                });
+            }
+        )
+    ];
+}