@yarkivaev/scada 2.3.53 → 2.3.55

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yarkivaev/scada",
-  "version": "2.3.53",
+  "version": "2.3.55",
   "description": "SCADA domain objects, state persistence, and plant monitoring",
   "repository": {
     "type": "git",

package/src/application/metricsPlant.js

@@ -29,6 +29,7 @@ export default async function metricsPlant(machines, options) {
         pool,
         alerts: options.alerts,
         userDecisions: options.userDecisions,
+        segments: options.segments,
         shopName: options.shopName
     });
     return plant(initialized({ [shop.name()]: shop }, Object.values));

package/src/application/plantApi.js

@@ -12,12 +12,16 @@ import simulationRoute from '../infrastructure/http/plant/routes/simulationRoute
 import catalogRoute from '../infrastructure/http/plant/routes/catalogRoute.js';
 import { routes } from '@yarkivaev/simple-server';
 
+function pass(_id, rows) {
+    return rows;
+}
+
 /**
  * Composable plant HTTP API factory.
  *
  * @param {string} basePath - base URL path
  * @param {object} plant - plant domain object with operations (optional kindSources at construction)
- * @param {object} [config] - clock, extraRoutes, requestTimeoutMs, heartbeat
+ * @param {object} [config] - clock, extraRoutes, requestTimeoutMs, heartbeat, decorateTimeline
  * @returns {object} routes with list() and handle()
  *
  * @example
@@ -30,6 +34,7 @@ export default function plantApi(basePath, plant, config) {
         return new Date();
     });
     const extra = opts.extraRoutes || [];
+    const decorate = opts.decorateTimeline || pass;
     const routeList = [
         ...catalogRoute(basePath, opts.tagCatalog),
         ...machineRoute(basePath, plant),
@@ -37,8 +42,8 @@ export default function plantApi(basePath, plant, config) {
         ...measurementRoute(basePath, plant, time),
         ...alertStream(basePath, plant, time),
         ...alertRoute(basePath, plant),
-        ...timelineRoute(basePath, plant, opts.timelineOperator),
-        ...timelineStream(basePath, plant, time),
+        ...timelineRoute(basePath, plant, opts.timelineOperator, decorate),
+        ...timelineStream(basePath, plant, time, decorate),
         ...operationRoute(basePath, plant, opts.timelineOperator, opts.operationDecisions, opts.owners),
         ...operationStream(basePath, plant, time),
         ...heartbeatStream(basePath, time, opts.heartbeat),

package/src/application/plantServer.js

@@ -6,6 +6,7 @@ import postgresPool from '../infrastructure/persistence/postgresPool.js';
 import stompAlerts from '../infrastructure/messaging/stomp/alerts/stompAlerts.js';
 import stompTimelineSegments from '../infrastructure/messaging/stomp/stompTimelineSegments.js';
 import userDecisions from '../infrastructure/messaging/stomp/userDecisions.js';
+import segmentRetags from '../infrastructure/messaging/stomp/segmentRetags.js';
 import { parseRequestTimeoutMs, virtualClock } from '@yarkivaev/simple-server';
 
 function stompCollectorFactory(stompUrl, destination, credentials) {
@@ -63,7 +64,13 @@ async function initStomp(stomp, translations, requirePool) {
         passcode: stomp.passcode,
         host: stomp.host
     });
-    return { alerts, userDecisions: decisions };
+    const segments = segmentRetags({
+        stompUrl: stomp.url,
+        login: stomp.login,
+        passcode: stomp.passcode,
+        host: stomp.host
+    });
+    return { alerts, userDecisions: decisions, segments };
 }
 
 /**
@@ -72,15 +79,15 @@ async function initStomp(stomp, translations, requirePool) {
  * Multi-kind operations come from plant.operations built with kindSources
  * (e.g. plantOperations(persistence, { temp })).
  *
- * @param {object} config - port, basePath, plantFactory, extraRoutes, translations, stomp, requirePool
+ * @param {object} config - port, basePath, plantFactory, extraRoutes, translations, stomp, requirePool, decorateTimeline
  * @returns {Promise<object>} server, plant, api, segments
  *
  * @example
  *   await plantServer({ port: 3000, basePath: '/api/v1', plantFactory, extraRoutes });
  */
 export default async function plantServer(config) {
-    const { alerts, userDecisions: decisions } = await initStomp(config.stomp, config.translations, config.requirePool);
-    const p = await config.plantFactory({ alerts, userDecisions: decisions });
+    const { alerts, userDecisions: decisions, segments: retags } = await initStomp(config.stomp, config.translations, config.requirePool);
+    const p = await config.plantFactory({ alerts, userDecisions: decisions, segments: retags });
     const segments = wireTimelineSegments(config.stomp, p);
     const clock = virtualClock(() => {
         return new Date();
@@ -95,7 +102,8 @@ export default async function plantServer(config) {
         extraRoutes: extra,
         timelineOperator: config.timelineOperator,
         operationDecisions: config.operationDecisions,
-        owners: config.owners
+        owners: config.owners,
+        decorateTimeline: config.decorateTimeline
     });
     const server = http.createServer((req, res) => {
         return api.handle(req, res);

package/src/application/shopWithTimeline.js

@@ -1,9 +1,11 @@
 import pubsub from '../domain/shared/pubsub.js';
 import timeline from '../domain/timeline/timeline.js';
 import pgTimeline from '../infrastructure/persistence/pg/timeline.js';
+import segmentStatePg from '../infrastructure/persistence/pg/segments.js';
 import memoryTimelineStore, { memoryTimelineRead } from '../infrastructure/persistence/memory/timeline.js';
 import ownerTimeline from '../infrastructure/messaging/ownership/ownerTimeline.js';
 import stompTimeline from '../infrastructure/messaging/stomp/timeline.js';
+import retagBody from '../infrastructure/messaging/stomp/retagBody.js';
 
 function parseStart(requestId) {
     const raw = decodeURIComponent(String(requestId));
@@ -69,6 +71,34 @@ function writePort(name, decisions, owners) {
     }, owners)(name);
 }
 
+function ownsLocal(owners, name) {
+    if (!owners) {
+        return true;
+    }
+    return owners.resolve(name).kind !== 'edge';
+}
+
+async function persistTags(pool, patch) {
+    const state = segmentStatePg(pool);
+    const tagsJson = JSON.stringify(patch.tags);
+    const propsJson = JSON.stringify(patch.properties || {});
+    const count = patch.resolved
+        ? await state.resolveRequest(patch.machine, patch.start, tagsJson, propsJson)
+        : await state.retag(patch.machine, patch.start, tagsJson, propsJson);
+    if (!count) {
+        throw new RangeError(`Segment ${patch.machine} at ${patch.start.toISOString()} was not updated`);
+    }
+    return state.rowAt(patch.machine, patch.start);
+}
+
+async function confirm(pool, patch, segments) {
+    const row = await persistTags(pool, patch);
+    if (segments) {
+        await segments.publish(retagBody(patch.machine, row, patch.tags, patch.properties || {}));
+    }
+    return row;
+}
+
 /**
  * Builds a machine timeline from PostgreSQL persistence and STOMP user decisions.
  *
@@ -82,7 +112,7 @@ function writePort(name, decisions, owners) {
  *   const tl = shopWithTimeline('machine1', { pool, userDecisions, owners });
  */
 export default function shopWithTimeline(name, options) {
-    const { pool, userDecisions: decisions, owners } = options;
+    const { pool, userDecisions: decisions, owners, segments } = options;
     if (pool && decisions) {
         const bus = pubsub();
         const read = pgTimeline(pool, name);
@@ -95,11 +125,29 @@ export default function shopWithTimeline(name, options) {
             stream: port.stream,
             bus,
             async retag(start, tags, properties, audit) {
+                if (ownsLocal(owners, name)) {
+                    await confirm(pool, {
+                        machine: name,
+                        start,
+                        tags,
+                        properties,
+                        resolved: false
+                    }, segments);
+                }
                 await write.retag(start, tags, properties, audit);
                 bus.emit({ type: 'resolved', segment: resolvedStub(start, tags, properties), audit });
             },
             async respond(requestId, body, audit) {
                 const start = parseStart(requestId);
+                if (ownsLocal(owners, name)) {
+                    await confirm(pool, {
+                        machine: name,
+                        start,
+                        tags: body.tags,
+                        properties: body.properties || {},
+                        resolved: true
+                    }, segments);
+                }
                 await write.respond(start, body.tags, body.properties || {}, audit);
                 bus.emit({ type: 'resolved', request: { id: requestId, start }, audit });
                 return { id: requestId, ...body };

package/src/application/siteServer.js

@@ -142,7 +142,7 @@ function siteExtraRoutes(catalog, extraRoutes) {
 /**
  * Unified site process: supervisor-sink HTTP, plant API, and optional MQTT ingest.
  *
- * @param {object} config - port, basePath, translations, requirePool, plantFactory, extraRoutes, operatorCatalog, kindSources, streams, env
+ * @param {object} config - port, basePath, translations, requirePool, plantFactory, extraRoutes, operatorCatalog, kindSources, streams, env, decorateTimeline
  * @returns {Promise<object>} sink, plant, mqtt pipeline
  *
  * @example
@@ -185,7 +185,8 @@ export default async function siteServer(config) {
         extraRoutes: siteExtraRoutes(catalog, config.extraRoutes),
         timelineOperator: timelineOperatorFromEnv(catalog, env, config),
         operationDecisions: catalog.decisions,
-        owners: config.owners
+        owners: config.owners,
+        decorateTimeline: config.decorateTimeline
     });
     return { sink, plant, mqtt, telemetry, operationSync, operatorsSync: catalog.sync };
 }

package/src/domain/timeline/cycleLookback.js

@@ -0,0 +1,37 @@
+function tagList(row) {
+    const raw = row.tags;
+    if (Array.isArray(raw)) {
+        return raw;
+    }
+    if (typeof raw === 'string' && raw.length > 0) {
+        return JSON.parse(raw);
+    }
+    return [];
+}
+
+/**
+ * Walks newest-first timeline rows until a reset tag and returns them oldest-first.
+ *
+ * Reset ids are opaque; callers pass cycle start/stop tags.
+ *
+ * @param {Array<object>} rows - newest-first rows with tags
+ * @param {Array<string>} resetTags - tag ids that close the lookback
+ * @returns {Array<object>} chronological slice including the reset row
+ *
+ * @example
+ *   cycleLookback(newestFirst, ['cycle-start', 'cycle-stop'])
+ */
+export default function cycleLookback(rows, resetTags) {
+    const reset = new Set(resetTags);
+    const collected = [];
+    for (let i = 0; i < rows.length; i += 1) {
+        const row = rows[i];
+        collected.push(row);
+        if (tagList(row).some((id) => {
+            return reset.has(id);
+        })) {
+            break;
+        }
+    }
+    return collected.reverse();
+}

package/src/infrastructure/http/edge/routes/checkpoint/checkpointRoutes.js

@@ -37,6 +37,38 @@ function segmentRoute(token, checkpointState) {
     });
 }
 
+function cyclePriorQuery(query) {
+    if (!query.machineId) {
+        return { error: 'machineId is required' };
+    }
+    const before = parseFrom(query.before);
+    if (before === null) {
+        return { error: 'before must be a number' };
+    }
+    const reset = toTopicList(query.reset);
+    if (reset.length === 0) {
+        return { error: 'reset is required' };
+    }
+    return { machineId: query.machineId, before, reset };
+}
+
+function cyclePriorRoute(token, checkpointState) {
+    return route('GET', '/v1/checkpoint/cycle-prior', async (req, res, params, query) => {
+        void params;
+        if (!hasAccess(req, token)) {
+            sendForbidden(res);
+            return;
+        }
+        const parsed = cyclePriorQuery(query);
+        if (parsed.error) {
+            errorResponse('BAD_REQUEST', parsed.error, 400).send(res);
+            return;
+        }
+        const items = await checkpointState.cyclePrior(parsed.machineId, parsed.before, parsed.reset);
+        jsonResponse({ items }).send(res);
+    });
+}
+
 export default function checkpointRoutes(token, checkpointState) {
     return [
         route('GET', '/v1/checkpoint/replay-cursor', async (req, res, params, query) => {
@@ -53,6 +85,7 @@ export default function checkpointRoutes(token, checkpointState) {
             jsonResponse({ machineId: query.machineId, cursor }).send(res);
         }),
         segmentRoute(token, checkpointState),
+        cyclePriorRoute(token, checkpointState),
         route('GET', '/v1/checkpoint/pending-segments', async (req, res) => {
             if (!hasAccess(req, token)) {
                 sendForbidden(res);

package/src/infrastructure/http/plant/routes/timelineRoute.js

@@ -9,12 +9,16 @@ async function handleOperatorWrite(gate, parsed, write) {
     await write(audit);
 }
 
-async function rejectUnknownTags(timeline, parsed, machineId, res) {
+async function rejectUnknownTags(timeline, parsed, machineId, res, decorate) {
     if (typeof timeline.rowAt !== 'function') {
         return false;
     }
     const row = await timeline.rowAt(new Date(parsed.start));
-    if (!row || allowedSegmentTags(row.options, row.tags, parsed.tags)) {
+    if (!row) {
+        return false;
+    }
+    const [gated] = await decorate(machineId, [row]);
+    if (allowedSegmentTags(gated.options, gated.tags, parsed.tags)) {
         return false;
     }
     errorResponse('BAD_REQUEST', `Tag is not in segment options for ${machineId}`, 400).send(res);
@@ -41,12 +45,13 @@ async function respondToRequest(gate, timeline, requestId, req, res) {
  * @param {string} basePath - base URL path
  * @param {object} plant - plant domain object
  * @param {object} [operatorOptions] - provider, requireOperator, defaultUser
+ * @param {function} decorate - (machineId, rows) => rows, applied before JSON and PATCH gate
  * @returns {array} route objects
  *
  * @example
  *   timelineRoute('/api/v1', plant, { provider, requireOperator: true, defaultUser: 'hmi-kiosk' });
  */
-export default function timelineRoute(basePath, plant, operatorOptions) {
+export default function timelineRoute(basePath, plant, operatorOptions, decorate) {
     const gate = timelineOperator(operatorOptions);
     return [
         route('GET', `${basePath}/machines/:machineId/segments`, async (req, res, params, query) => {
@@ -62,7 +67,7 @@ export default function timelineRoute(basePath, plant, operatorOptions) {
             if (query.to) {
                 options.to = query.to;
             }
-            const rows = await result.machine.timeline.list(options);
+            const rows = await decorate(params.machineId, await result.machine.timeline.list(options));
             jsonResponse({ items: rows.map(segmentJson) }).send(res);
         }),
         route('PATCH', `${basePath}/machines/:machineId/segments`, async (req, res, params) => {
@@ -74,7 +79,7 @@ export default function timelineRoute(basePath, plant, operatorOptions) {
             try {
                 const raw = await readBody(req);
                 const parsed = JSON.parse(raw);
-                if (await rejectUnknownTags(result.machine.timeline, parsed, params.machineId, res)) {
+                if (await rejectUnknownTags(result.machine.timeline, parsed, params.machineId, res, decorate)) {
                     return;
                 }
                 await handleOperatorWrite(gate, parsed, async (audit) => {
@@ -94,7 +99,7 @@ export default function timelineRoute(basePath, plant, operatorOptions) {
                 jsonResponse({ items: [] }).send(res);
                 return;
             }
-            const rows = await result.machine.timeline.pending();
+            const rows = await decorate(params.machineId, await result.machine.timeline.pending());
             const items = rows.map(({ id, name, start_time: startTime, end_time: endTime, duration, options }) => {
                 return {
                     id,

package/src/infrastructure/http/plant/streams/timelineStream.js

@@ -22,18 +22,53 @@ function segmentPayload(segment) {
     return data;
 }
 
+async function emitSegment(sse, event, decorate, machineId) {
+    if (event.type === 'created' && event.segment) {
+        const [row] = await decorate(machineId, [event.segment]);
+        sse.emit('segment_created', segmentPayload(row));
+        return;
+    }
+    if (event.type === 'resolved' && event.segment) {
+        const [row] = await decorate(machineId, [event.segment]);
+        sse.emit('segment_resolved', segmentPayload(row));
+    }
+}
+
+async function emitRequest(sse, event, decorate, machineId) {
+    if (event.type === 'created' && event.request) {
+        const [row] = await decorate(machineId, [event.request]);
+        const start = row.start_time || row.startTime;
+        const end = row.end_time || row.endTime;
+        sse.emit('request_created', {
+            id: row.id,
+            segment: {
+                name: row.name,
+                start: start.toISOString(),
+                end: end.toISOString(),
+                duration: row.duration
+            },
+            options: row.options
+        });
+        return;
+    }
+    if (event.type === 'resolved' && event.request) {
+        sse.emit('request_resolved', { id: event.request.id });
+    }
+}
+
 /**
  * Timeline SSE routes for segments and label requests.
  *
  * @param {string} basePath - base URL path
  * @param {object} plant - plant domain object
  * @param {function} clock - time provider
+ * @param {function} decorate - (machineId, rows) => rows
  * @returns {array} route objects
  *
  * @example
  *   timelineStream('/api/v1', plant, clock);
  */
-export default function timelineStream(basePath, plant, clock) {
+export default function timelineStream(basePath, plant, clock, decorate) {
     return [
         route('GET', `${basePath}/machines/:machineId/segments/stream`, (req, res, params) => {
             const sse = sseResponse(res, clock);
@@ -44,11 +79,7 @@ export default function timelineStream(basePath, plant, clock) {
                 return;
             }
             const subscription = result.machine.timeline.stream((event) => {
-                if (event.type === 'created' && event.segment) {
-                    sse.emit('segment_created', segmentPayload(event.segment));
-                } else if (event.type === 'resolved' && event.segment) {
-                    sse.emit('segment_resolved', segmentPayload(event.segment));
-                }
+                return emitSegment(sse, event, decorate, params.machineId);
             });
             const heartbeat = setInterval(() => {
                 sse.heartbeat();
@@ -67,23 +98,7 @@ export default function timelineStream(basePath, plant, clock) {
                 return;
             }
             const subscription = result.machine.timeline.stream((event) => {
-                if (event.type === 'created' && event.request) {
-                    const reqItem = event.request;
-                    const start = reqItem.start_time || reqItem.startTime;
-                    const end = reqItem.end_time || reqItem.endTime;
-                    sse.emit('request_created', {
-                        id: reqItem.id,
-                        segment: {
-                            name: reqItem.name,
-                            start: start.toISOString(),
-                            end: end.toISOString(),
-                            duration: reqItem.duration
-                        },
-                        options: reqItem.options
-                    });
-                } else if (event.type === 'resolved' && event.request) {
-                    sse.emit('request_resolved', { id: event.request.id });
-                }
+                return emitRequest(sse, event, decorate, params.machineId);
             });
             const heartbeat = setInterval(() => {
                 sse.heartbeat();

package/src/infrastructure/messaging/stomp/retagBody.js

@@ -0,0 +1,39 @@
+function asList(raw) {
+    if (Array.isArray(raw)) {
+        return raw;
+    }
+    if (typeof raw === 'string' && raw.length > 0) {
+        return JSON.parse(raw);
+    }
+    return [];
+}
+
+/**
+ * Builds a segments-exchange retag payload matching supervisor SegmentMessage.retag.
+ *
+ * @param {string} machine - machine id
+ * @param {object} row - persisted segment with start_time, end_time, duration, name, options
+ * @param {string[]} tags - operator tags
+ * @param {object} properties - operator properties
+ * @returns {object} STOMP JSON body
+ *
+ * @example
+ *   retagBody('icht1', row, ['to_ladle'], {})
+ */
+export default function retagBody(machine, row, tags, properties) {
+    const options = asList(row.options);
+    const props = properties && Object.keys(properties).length > 0 ? properties : null;
+    return {
+        type: 'retag',
+        status: 'completed',
+        machine,
+        name: row.name,
+        start: new Date(row.start_time).getTime(),
+        end: new Date(row.end_time).getTime(),
+        duration: row.duration,
+        tags,
+        options: options.length > 0 ? options : null,
+        properties: props,
+        resolved: true
+    };
+}

package/src/infrastructure/messaging/stomp/segmentRetags.js

@@ -0,0 +1,35 @@
+import { stompSend } from '@yarkivaev/source-to-sink';
+
+const DEFAULT_DESTINATION = '/exchange/scada.segments';
+
+/**
+ * Publishes operator retag envelopes to the segments exchange.
+ *
+ * @param {object} config - publisher configuration
+ * @param {string} config.stompUrl - STOMP broker URL
+ * @param {string} [config.destination] - STOMP destination
+ * @param {string} [config.login] - STOMP login
+ * @param {string} [config.passcode] - STOMP passcode
+ * @param {string} [config.host] - STOMP vhost header
+ * @returns {object} publisher with publish(body)
+ *
+ * @example
+ *   const retags = segmentRetags({ stompUrl });
+ *   await retags.publish(retagBody('icht1', row, ['to_ladle'], {}));
+ */
+export default function segmentRetags(config) {
+    if (!config.stompUrl) {
+        throw new Error('stompUrl is required for segment retag publisher');
+    }
+    const destination = config.destination || DEFAULT_DESTINATION;
+    const stompOptions = {
+        login: config.login,
+        passcode: config.passcode,
+        host: config.host
+    };
+    return {
+        async publish(body) {
+            await stompSend(config.stompUrl, destination, body, stompOptions);
+        }
+    };
+}

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

@@ -1,3 +1,5 @@
+import cycleLookback from '../../../domain/timeline/cycleLookback.js';
+
 function parseJsonField(raw) {
     if (!raw) {
         return null;
@@ -93,6 +95,17 @@ export default function checkpointStateMemory(store) {
         },
         segment(machineId, startEpoch) {
             return segmentAt(store, machineId, startEpoch);
+        },
+        cyclePrior(machineId, beforeEpoch, resetTags) {
+            const beforeMs = Number(beforeEpoch) * 1000;
+            const rows = store.segments.filter((row) => {
+                return row.machine === machineId && new Date(row.start_time).getTime() < beforeMs;
+            }).sort((a, b) => {
+                return new Date(b.start_time) - new Date(a.start_time);
+            });
+            return cycleLookback(rows, resetTags).map((row) => {
+                return segmentItem(row);
+            });
         }
     };
 }

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

@@ -65,19 +65,23 @@ export default function segmentStateMemory(store) {
         },
         retag(machineId, start, tagsJson, propertiesJson) {
             const row = findRow(store, machineId, start);
-            if (row) {
-                row.tags = tagsJson;
-                row.properties = propertiesJson;
+            if (!row) {
+                return 0;
             }
+            row.tags = tagsJson;
+            row.properties = propertiesJson;
+            return 1;
         },
         resolveRequest(machineId, startKey, tagsJson, propertiesJson) {
             const row = findRow(store, machineId, startKey);
-            if (row) {
-                row.tags = tagsJson;
-                row.properties = propertiesJson;
-                row.resolved = true;
-                row.consumed = false;
+            if (!row) {
+                return 0;
             }
+            row.tags = tagsJson;
+            row.properties = propertiesJson;
+            row.resolved = true;
+            row.consumed = false;
+            return 1;
         }
     };
 }

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

@@ -1,4 +1,5 @@
 import segmentStatePg from './segments.js';
+import cycleLookback from '../../../domain/timeline/cycleLookback.js';
 
 function parseJsonField(raw) {
     if (!raw) {
@@ -110,6 +111,19 @@ export default function checkpointStatePg(pool, metricsEnabled = true) {
         },
         segment(machineId, startEpoch) {
             return segmentAt(pool, machineId, startEpoch);
+        },
+        cyclePrior(machineId, beforeEpoch, resetTags) {
+            return pool.query(
+                `SELECT name, start_time, end_time, duration, tags, options, properties
+                 FROM segments
+                 WHERE machine = $1 AND start_time < $2
+                 ORDER BY start_time DESC`,
+                [machineId, new Date(beforeEpoch * 1000)]
+            ).then((result) => {
+                return cycleLookback(result.rows, resetTags).map((row) => {
+                    return segmentItem(row, machineId);
+                });
+            });
         }
     };
 }

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

@@ -33,16 +33,18 @@ export default function segmentStatePg(pool) {
             return result.rows;
         },
         async retag(machineId, start, tagsJson, propertiesJson) {
-            await pool.query(
+            const result = await pool.query(
                 'UPDATE segments SET tags = $1, properties = $2 WHERE machine = $3 AND start_time = $4',
                 [tagsJson, propertiesJson, machineId, start]
             );
+            return result.rowCount;
         },
         async resolveRequest(machineId, startKey, tagsJson, propertiesJson) {
-            await pool.query(
+            const result = 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]
             );
+            return result.rowCount;
         }
     };
 }