@yarkivaev/scada 2.3.46 → 2.3.48

package/db/migrations/E0003__edge_operations_grants.sql

@@ -1,2 +1,2 @@
-GRANT SELECT, INSERT, UPDATE ON operations TO supervisor_sink;
+GRANT SELECT, INSERT, UPDATE, DELETE ON operations TO supervisor_sink;
 GRANT SELECT, INSERT, UPDATE ON ingest_checkpoints TO supervisor_sink;

package/db/migrations/E0004__edge_operations_delete.sql

@@ -0,0 +1 @@
+GRANT DELETE ON operations TO supervisor_sink;

package/db/migrations/V0006__operations_machine_kind_time.sql

@@ -0,0 +1,2 @@
+CREATE INDEX IF NOT EXISTS idx_operations_machine_kind_time
+    ON operations (machine, kind, occurred_at);

package/package.json

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

package/src/application/plantOperations.js

@@ -6,9 +6,9 @@ import pubsub from '../domain/shared/pubsub.js';
  *
  * Optional kindSources inject non-PG kinds into listForMachine merges.
  *
- * @param {object} persistence - operations store with upsert, get, remove, listForMachine
+ * @param {object} persistence - operations store with upsert, get, remove, listForMachine, latestForMachine
  * @param {object} [kindSources] - map of kind to { list(machineId, range) }
- * @returns {object} operations with listForMachine, upsert, get, remove, and stream
+ * @returns {object} operations with listForMachine, latestForMachine, upsert, get, remove, and stream
  *
  * @example
  *   const ops = plantOperations(dataAccess.operations, { temp: temperaturePort });

package/src/domain/operation/operations.js

@@ -32,15 +32,17 @@ function resolveKinds(kinds, sources) {
  *
  * listForMachine merges requested kinds from injectable sources and Postgres,
  * sorted by occurred_at. Omitted kinds default to injectable source keys.
+ * latestForMachine reads only from persistence (single kind).
  *
- * @param {object} persistence - store with upsert, get, remove, listForMachine
+ * @param {object} persistence - store with upsert, get, remove, listForMachine, latestForMachine
  * @param {object} bus - pubsub instance with stream and emit methods
  * @param {object} [kindSources] - map of kind to { list(machineId, range) }
- * @returns {object} operations with listForMachine, upsert, get, remove, stream
+ * @returns {object} operations with listForMachine, latestForMachine, upsert, get, remove, stream
  *
  * @example
  *   const ops = operations(store, bus, { temp: temperaturePort });
  *   await ops.listForMachine('m1', ['chem', 'temp'], { from: new Date() });
+ *   await ops.latestForMachine('m1', 'chem', { to: new Date() });
  *   await ops.remove('m1', 'nb-1');
  */
 export default function operations(persistence, bus, kindSources) {
@@ -59,6 +61,9 @@ export default function operations(persistence, bus, kindSources) {
                 });
             });
         },
+        latestForMachine(machineId, kind, bound) {
+            return persistence.latestForMachine(machineId, kind, bound);
+        },
         upsert(item) {
             const updatedAt = new Date();
             const row = stampRow(item, updatedAt);

package/src/infrastructure/ingest/db/migrationProfile.js

@@ -21,7 +21,8 @@ const privilegedOnly = new Set([
     'C0005__central_operators_grants.sql',
     'C0006__central_operators_registration.sql',
     'E0002__edge_retention_delete.sql',
-    'E0003__edge_operations_grants.sql'
+    'E0003__edge_operations_grants.sql',
+    'E0004__edge_operations_delete.sql'
 ]);
 
 /**

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

@@ -37,6 +37,41 @@ function filterList(store, machineId, kind, range) {
     });
 }
 
+/**
+ * Picks the latest matching row for a machine and kind at a time bound.
+ *
+ * @param {object} store - shared mutable store with operations array
+ * @param {string} machineId - machine identifier
+ * @param {string} kind - operation kind
+ * @param {{ to?: Date, before?: Date }} bound - inclusive to or exclusive before
+ * @returns {object|null} latest row or null
+ */
+function filterLatest(store, machineId, kind, bound) {
+    const range = bound || {};
+    const before = range.before ? new Date(range.before).getTime() : null;
+    const to = range.to ? new Date(range.to).getTime() : null;
+    const matches = store.operations.filter((row) => {
+        if (row.machine !== machineId || row.kind !== kind) {
+            return false;
+        }
+        const at = new Date(row.occurred_at).getTime();
+        if (before !== null && at >= before) {
+            return false;
+        }
+        if (to !== null && at > to) {
+            return false;
+        }
+        return true;
+    }).sort((left, right) => {
+        const delta = new Date(right.occurred_at) - new Date(left.occurred_at);
+        if (delta !== 0) {
+            return delta;
+        }
+        return String(right.key).localeCompare(String(left.key));
+    });
+    return matches[0] || null;
+}
+
 /**
  * In-memory operations state port for tests and local runs.
  *
@@ -82,6 +117,9 @@ export default function operationStateMemory(store) {
         },
         listForMachine(machineId, kind, range) {
             return Promise.resolve(filterList(store, machineId, kind, range));
+        },
+        latestForMachine(machineId, kind, bound) {
+            return Promise.resolve(filterLatest(store, machineId, kind, bound));
         }
     };
 }

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

@@ -38,6 +38,33 @@ function listForMachine(pool, machineId, kind, range) {
     });
 }
 
+/**
+ * Loads the latest operation for a machine and kind at or before a bound.
+ *
+ * @param {object} pool - pg pool
+ * @param {string} machineId - machine identifier
+ * @param {string} kind - operation kind
+ * @param {{ to?: Date, before?: Date }} bound - inclusive to or exclusive before
+ * @returns {Promise<object|null>} latest row or null
+ */
+function latestForMachine(pool, machineId, kind, bound) {
+    const range = bound || {};
+    let sql = `SELECT machine, occurred_at, kind, key, payload
+        FROM operations WHERE machine = $1 AND kind = $2`;
+    const prm = [machineId, kind];
+    if (range.before) {
+        prm.push(range.before);
+        sql += ` AND occurred_at < $${prm.length}`;
+    } else if (range.to) {
+        prm.push(range.to);
+        sql += ` AND occurred_at <= $${prm.length}`;
+    }
+    sql += ' ORDER BY occurred_at DESC, key DESC LIMIT 1';
+    return pool.query(sql, prm).then((result) => {
+        return result.rows[0] || null;
+    });
+}
+
 function missing(machineId, key) {
     return new Error(`operation '${key}' not found for machine '${machineId}'`);
 }
@@ -70,11 +97,12 @@ async function removeOperation(pool, machineId, key) {
  * PostgreSQL operations persistence port for generic machine operations.
  *
  * @param {object} pool - pg pool
- * @returns {object} operations port with upsert, get, remove, and listForMachine
+ * @returns {object} operations port with upsert, get, remove, listForMachine, latestForMachine
  *
  * @example
  *   const store = operationStatePg(pool);
  *   await store.upsert({ machine: 'm1', key: 'nb-1', kind: 'chem', ... });
+ *   await store.latestForMachine('m1', 'chem', { to: new Date() });
  *   await store.remove('m1', 'nb-1');
  */
 export default function operationStatePg(pool) {
@@ -90,6 +118,9 @@ export default function operationStatePg(pool) {
         },
         listForMachine(machineId, kind, range) {
             return listForMachine(pool, machineId, kind, range);
+        },
+        latestForMachine(machineId, kind, bound) {
+            return latestForMachine(pool, machineId, kind, bound);
         }
     };
 }