@yarkivaev/scada 2.3.58 → 2.3.59

package/package.json

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

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

@@ -99,7 +99,7 @@ function filterLatest(store, machineId, kind, bound) {
  * In-memory operations state port for tests and local runs.
  *
  * @param {object} store - shared mutable store with operations array
- * @returns {object} operations port matching operationStatePg shape
+ * @returns {object} operations port matching operationStatePg shape including drop
  */
 export default function operationStateMemory(store) {
     if (!store.operations) {
@@ -126,6 +126,15 @@ export default function operationStateMemory(store) {
             const [row] = store.operations.splice(index, 1);
             return Promise.resolve(row);
         },
+        drop(machineId, key) {
+            const index = store.operations.findIndex((row) => {
+                return row.machine === machineId && row.key === key;
+            });
+            if (index >= 0) {
+                store.operations.splice(index, 1);
+            }
+            return Promise.resolve();
+        },
         listForMachine(machineId, kind, range) {
             return Promise.resolve(filterList(store, machineId, kind, range));
         },

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

@@ -120,17 +120,33 @@ async function removeOperation(pool, machineId, key) {
     return result.rows[0];
 }
 
+/**
+ * Deletes an operation when present. Absence is success.
+ *
+ * @param {object} pool - pg pool
+ * @param {string} machineId - machine identifier
+ * @param {string} key - operation storage key
+ * @returns {Promise<void>}
+ */
+function dropOperation(pool, machineId, key) {
+    return pool.query(
+        'DELETE FROM operations WHERE machine = $1 AND key = $2',
+        [machineId, key]
+    );
+}
+
 /**
  * PostgreSQL operations persistence port for generic machine operations.
  *
  * @param {object} pool - pg pool
- * @returns {object} operations port with upsert, get, remove, listForMachine, latestForMachine
+ * @returns {object} operations port with upsert, get, remove, drop, listForMachine, latestForMachine
  *
  * @example
  *   const store = operationStatePg(pool);
  *   await store.upsert({ machine: 'm1', key: 'nb-1', kind: 'sample', ... });
  *   await store.latestForMachine('m1', 'sample', { to: new Date() });
  *   await store.remove('m1', 'nb-1');
+ *   await store.drop('m1', 'nb-1');
  */
 export default function operationStatePg(pool) {
     return {
@@ -143,6 +159,9 @@ export default function operationStatePg(pool) {
         remove(machineId, key) {
             return removeOperation(pool, machineId, key);
         },
+        drop(machineId, key) {
+            return dropOperation(pool, machineId, key);
+        },
         listForMachine(machineId, kind, range) {
             return listForMachine(pool, machineId, kind, range);
         },

package/src/infrastructure/sync/operationSyncSink.js

@@ -3,7 +3,9 @@ import processingErrorLog from '../ingest/processingErrorLog.js';
 /**
  * PostgreSQL sink for generic operation sync records.
  *
- * @param {object} operations - Operations port with upsert(item) and remove(machineId, key)
+ * Federated deletes call operations.drop, which is idempotent when the row is absent.
+ *
+ * @param {object} operations - Operations port with upsert(item) and drop(machineId, key)
  * @returns {object} Sink with accept() and remove() methods
  *
  * @example
@@ -26,7 +28,7 @@ export default function operationSyncSink(operations) {
         },
         async remove(record) {
             try {
-                await operations.remove(record.machine, record.key);
+                await operations.drop(record.machine, record.key);
             } catch (error) {
                 processingErrorLog('operation_sync_sink', error, {
                     machine: record.machine,