signalk-edge-link 2.5.0 → 2.5.1

package/lib/config-watcher.js

@@ -51,42 +51,37 @@ const crypto = __importStar(require("crypto"));
 const config_io_1 = require("./config-io");
 const constants_1 = require("./constants");
 const { readFile, writeFile, mkdir } = fs_1.promises;
-/**
- * Create a debounced config-change handler.
- */
 function createDebouncedConfigHandler(opts) {
     const { name, getFilePath, processConfig, state, instanceId, app, readFallback } = opts;
-    return function handleChange() {
+    async function runLoad() {
+        if (state.stopped)
+            return;
+        let content;
+        const filePath = getFilePath();
+        if (readFallback !== undefined) {
+            content = filePath ? await readFile(filePath, "utf-8").catch(() => null) : null;
+        }
+        else {
+            content = filePath ? await readFile(filePath, "utf-8") : null;
+        }
+        if (state.stopped)
+            return;
+        const hashSource = content || JSON.stringify(readFallback) || "";
+        const contentHash = crypto.createHash(constants_1.CONTENT_HASH_ALGORITHM).update(hashSource).digest("hex");
+        if (contentHash === state.configContentHashes[name]) {
+            app.debug(`[${instanceId}] ${name} file unchanged, skipping`);
+            return;
+        }
+        const parsed = content ? JSON.parse(content) : readFallback;
+        await processConfig(parsed);
+        if (!state.stopped) {
+            state.configContentHashes[name] = contentHash;
+        }
+    }
+    const handleChange = function () {
         clearTimeout(state.configDebounceTimers[name]);
         state.configDebounceTimers[name] = setTimeout(() => {
-            (async () => {
-                if (state.stopped)
-                    return;
-                let content;
-                const filePath = getFilePath();
-                if (readFallback !== undefined) {
-                    content = filePath ? await readFile(filePath, "utf-8").catch(() => null) : null;
-                }
-                else {
-                    content = filePath ? await readFile(filePath, "utf-8") : null;
-                }
-                if (state.stopped)
-                    return;
-                const hashSource = content || JSON.stringify(readFallback) || "";
-                const contentHash = crypto
-                    .createHash(constants_1.CONTENT_HASH_ALGORITHM)
-                    .update(hashSource)
-                    .digest("hex");
-                if (contentHash === state.configContentHashes[name]) {
-                    app.debug(`[${instanceId}] ${name} file unchanged, skipping`);
-                    return;
-                }
-                const parsed = content ? JSON.parse(content) : readFallback;
-                await processConfig(parsed);
-                if (!state.stopped) {
-                    state.configContentHashes[name] = contentHash;
-                }
-            })().catch((err) => {
+            runLoad().catch((err) => {
                 if (state.stopped)
                     return;
                 const msg = err instanceof Error ? err.message : String(err);
@@ -94,6 +89,19 @@ function createDebouncedConfigHandler(opts) {
             });
         }, constants_1.FILE_WATCH_DEBOUNCE_DELAY);
     };
+    handleChange.flush = async function flush() {
+        clearTimeout(state.configDebounceTimers[name]);
+        try {
+            await runLoad();
+        }
+        catch (err) {
+            if (state.stopped)
+                return;
+            const msg = err instanceof Error ? err.message : String(err);
+            app.error(`[${instanceId}] Error handling ${name} change: ${msg}`);
+        }
+    };
+    return handleChange;
 }
 /**
  * Create a file-system watcher with automatic recovery on error or rename.

package/lib/instance.js

@@ -34,6 +34,7 @@ const config_watcher_1 = require("./config-watcher");
 const metadata_1 = require("./metadata");
 const delta_sanitizer_1 = require("./delta-sanitizer");
 const source_snapshot_1 = require("./source-snapshot");
+const values_snapshot_1 = require("./values-snapshot");
 const DELTA_SEND_MAX_RETRIES = 1;
 const DELTA_SEND_RETRY_BACKOFF_MS = 100;
 const SOURCE_SNAPSHOT_INTERVAL_MS = 60000;
@@ -404,6 +405,48 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
             app.debug(`[${instanceId}] source snapshot send failed: ${msg}`);
         }
     }
+    /**
+     * Replay every value currently in the local Signal K tree by feeding
+     * synthetic deltas through `processDelta`. The subscription manager only
+     * delivers *future* deltas, so values published into the tree before
+     * `subscribe()` ran (one-shot startup deltas, or deltas published by a
+     * co-located edge-link server-mode instance via `app.handleMessage`) would
+     * otherwise never reach the receiver. Triggered on initial subscribe
+     * success, on subscribe-retry success, and on UDP socket recovery so the
+     * receiver gets re-primed if it restarted.
+     *
+     * Returns silently if the SignalK app object doesn't expose `signalk`
+     * (older signalk-server versions or test mocks), or while the instance is
+     * not yet ready to send.
+     */
+    function replayValuesSnapshot(reason) {
+        if (state.stopped || !state.readyToSend || !state.processDelta) {
+            return;
+        }
+        let snapshot;
+        try {
+            snapshot = (0, values_snapshot_1.collectValuesSnapshot)(appProxy);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            app.debug(`[${instanceId}] values snapshot collect failed (${reason}): ${msg}`);
+            return;
+        }
+        if (snapshot.length === 0) {
+            return;
+        }
+        app.debug(`[${instanceId}] Replaying ${snapshot.length} value-snapshot delta(s) (${reason})`);
+        for (const delta of snapshot) {
+            try {
+                state.processDelta(delta);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                app.debug(`[${instanceId}] values snapshot replay failed (${reason}): ${msg}`);
+                return;
+            }
+        }
+    }
     function restartSourceSnapshotTimer() {
         clearInterval(state.sourceSnapshotTimer ?? undefined);
         state.sourceSnapshotTimer = null;
@@ -598,6 +641,9 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
                 }
                 state.readyToSend = true;
                 _setStatus("Subscription restored", true);
+                // Replay current tree state so any value that arrived in the tree
+                // while we were retrying isn't permanently lost.
+                replayValuesSnapshot("subscription retry");
             }
             catch (retryError) {
                 const msg = retryError instanceof Error ? retryError.message : String(retryError);
@@ -649,6 +695,12 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
                 if (state.metaConfig?.enabled) {
                     scheduleMetadataSnapshot(2000);
                 }
+                // Replay every value already present in the tree. Without this,
+                // one-shot startup deltas published before subscribe() ran (e.g. by
+                // a co-located edge-link server-mode instance) never reach the
+                // receiver, since the subscription manager only delivers future
+                // events.
+                replayValuesSnapshot("initial subscribe");
             }
             catch (subscribeError) {
                 // Re-subscribe failed — restore old handlers so stop() can still
@@ -713,8 +765,16 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
                 }
             ];
             state.configWatcherObjects = watcherConfigs.map((cfg) => (0, config_watcher_1.createWatcherWithRecovery)({ ...cfg, instanceId, app, state }));
-            // Trigger initial subscription load
-            handleSubscriptionChange();
+            // Trigger initial subscription load immediately (no debounce). The
+            // debounce delay exists to coalesce file-system change events; for the
+            // one-shot startup load it just widens the window during which deltas
+            // produced by co-located plugins are emitted before our subscription
+            // is registered with the subscriptionmanager — those deltas would be
+            // silently dropped since the manager only delivers future events.
+            handleSubscriptionChange.flush().catch((err) => {
+                const msg = err instanceof Error ? err.message : String(err);
+                app.error(`[${instanceId}] Initial subscription load failed: ${msg}`);
+            });
             app.debug(`[${instanceId}] Configuration file watchers initialized`);
         }
         catch (err) {
@@ -1001,6 +1061,10 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
                             if (state.metaConfig?.enabled) {
                                 scheduleMetadataSnapshot(1000);
                             }
+                            // Re-prime the receiver's value tree too — a restarted
+                            // receiver lost everything we sent before, and the
+                            // subscription manager won't replay past deltas.
+                            replayValuesSnapshot("socket recovery");
                         }
                         catch (recoveryErr) {
                             state.socketRecoveryInProgress = false;

package/lib/values-snapshot.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectValuesSnapshot = collectValuesSnapshot;
+// Reserved leaf-level keys we must not descend into when walking the tree.
+const SK_LEAF_KEYS = new Set([
+    "value",
+    "values",
+    "timestamp",
+    "$source",
+    "meta",
+    "sentence",
+    "pgn"
+]);
+// Top-level tree keys that aren't context groups.
+const SK_NON_CONTEXT_KEYS = new Set(["self", "version", "sources"]);
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readLeafFromNode(obj) {
+    // A Signal K value leaf has either a `value` property with sibling
+    // `timestamp`, or a multi-source `values` map. Single-source leaves are the
+    // common case so we handle them first.
+    if ("value" in obj && typeof obj.timestamp === "string") {
+        return {
+            value: obj.value,
+            timestamp: obj.timestamp,
+            source: typeof obj.$source === "string" ? obj.$source : undefined
+        };
+    }
+    return null;
+}
+function walkValues(node, pathParts, onLeaf) {
+    if (!isRecord(node)) {
+        return;
+    }
+    // Multi-source case wins when present: `values` is { sourceLabel:
+    // { value, timestamp } } and is more authoritative than the top-level
+    // `value`/`timestamp` (which mirror the latest of the multi-source map).
+    // Emit one leaf per source so the receiver retains attribution, then stop
+    // — the rest of the node is per-source bookkeeping.
+    if (isRecord(node.values)) {
+        for (const [sourceLabel, sourceData] of Object.entries(node.values)) {
+            if (isRecord(sourceData) &&
+                "value" in sourceData &&
+                typeof sourceData.timestamp === "string") {
+                onLeaf({
+                    path: pathParts.join("."),
+                    value: sourceData.value,
+                    timestamp: sourceData.timestamp,
+                    source: sourceLabel
+                });
+            }
+        }
+        return;
+    }
+    // Single-source leaf.
+    const single = readLeafFromNode(node);
+    if (single !== null) {
+        onLeaf({
+            path: pathParts.join("."),
+            value: single.value,
+            timestamp: single.timestamp,
+            source: single.source
+        });
+        return;
+    }
+    // Container — descend.
+    for (const key of Object.keys(node)) {
+        if (SK_LEAF_KEYS.has(key)) {
+            continue;
+        }
+        walkValues(node[key], pathParts.concat(key), onLeaf);
+    }
+}
+/**
+ * Build synthetic deltas for every value currently in the Signal K tree.
+ *
+ * Returns one delta per `(context, source)` pair, with all matching leaves
+ * grouped into a single `updates[].values[]` array. `DeltaUpdate.timestamp`
+ * is per-update (not per-leaf), so the latest timestamp across the group is
+ * used — receivers treat the delta as "current state" anyway.
+ *
+ * Returns [] when `app.signalk` isn't exposed (older signalk-server) or the
+ * tree is empty.
+ */
+function collectValuesSnapshot(app) {
+    if (!app.signalk || typeof app.signalk.retrieve !== "function") {
+        return [];
+    }
+    let tree;
+    try {
+        const retrieved = app.signalk.retrieve();
+        if (!isRecord(retrieved)) {
+            return [];
+        }
+        tree = retrieved;
+    }
+    catch {
+        return [];
+    }
+    // Group leaves by (context, source) so we emit one delta per group.
+    const grouped = new Map();
+    for (const contextGroup of Object.keys(tree)) {
+        if (SK_NON_CONTEXT_KEYS.has(contextGroup)) {
+            continue;
+        }
+        const group = tree[contextGroup];
+        if (!isRecord(group)) {
+            continue;
+        }
+        for (const contextId of Object.keys(group)) {
+            const contextNode = group[contextId];
+            if (!isRecord(contextNode)) {
+                continue;
+            }
+            const context = `${contextGroup}.${contextId}`;
+            walkValues(contextNode, [], (leaf) => {
+                const key = `${context}|${leaf.source ?? ""}`;
+                const existing = grouped.get(key);
+                if (existing) {
+                    existing.values.push({ path: leaf.path, value: leaf.value });
+                    if (leaf.timestamp > existing.timestamp) {
+                        existing.timestamp = leaf.timestamp;
+                    }
+                }
+                else {
+                    grouped.set(key, {
+                        context,
+                        source: leaf.source,
+                        timestamp: leaf.timestamp,
+                        values: [{ path: leaf.path, value: leaf.value }]
+                    });
+                }
+            });
+        }
+    }
+    const deltas = [];
+    for (const entry of grouped.values()) {
+        if (entry.values.length === 0) {
+            continue;
+        }
+        const update = {
+            timestamp: entry.timestamp,
+            values: entry.values
+        };
+        if (entry.source) {
+            update.$source = entry.source;
+        }
+        deltas.push({ context: entry.context, updates: [update] });
+    }
+    return deltas;
+}