@bldgblocks/node-red-contrib-control 0.1.33 → 0.1.36

package/nodes/units-block.js

@@ -1,58 +1,50 @@
 
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
     function UnitsBlockNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
 
         // Initialize runtime state
-        node.runtime = {
-            name: config.name,
-            unit: config.unit
-        };
+        // Initialize state
+        node.name = config.name;
+        node.inputProperty = config.inputProperty || "payload";
+        node.unit = config.unit;
 
         node.on("input", function(msg, send, done) {
             send = send || function() { node.send.apply(node, arguments); };
 
             // Validate input
             if (!msg || typeof msg !== "object" || !msg.hasOwnProperty("payload")) {
-                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                utils.setStatusError(node, "invalid message");
 
                 if (done) done();
                 return;
             }
 
             try {
-                // Handle configuration messages
-                if (msg.hasOwnProperty("context")) {
-                    // Configuration handling
-                    if (msg.context === "unit") {
-                        if (typeof msg.payload === "string") {
-                            node.runtime.unit = msg.payload;
-                            node.status({ fill: "green", shape: "dot", text: `unit: ${node.runtime.unit}` });
-                        } else {
-                            node.status({ fill: "red", shape: "ring", text: "invalid unit" });
-                        }
-                        if (done) done();
-                        return;
-                    }
-
-                    // Handle unknown context
-                    if (msg.context && msg.context !== "unit") {
-                        node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
-                        // Continue processing as passthrough
-                    }
-                }
-
                 // Process input
-                const payloadPreview = msg.payload !== null ? (typeof msg.payload === "number" ? msg.payload.toFixed(2) : JSON.stringify(msg.payload).slice(0, 20)) : "none";
+                let input;
+                try {
+                    input = RED.util.getMessageProperty(msg, node.inputProperty);
+                } catch (err) {
+                    input = undefined;
+                }
+                if (input === undefined) {
+                    utils.setStatusError(node, "missing or invalid input property");
+                    if (done) done();
+                    return;
+                }
+                
+                const payloadPreview = input !== null ? (typeof input === "number" ? input.toFixed(2) : JSON.stringify(input).slice(0, 20)) : "none";
 
-                node.status({ fill: "blue", shape: "dot", text: `in: ${payloadPreview} unit: ${node.runtime.unit !== "" ? node.runtime.unit : "none"}` });
+                utils.setStatusOK(node, `in: ${payloadPreview} unit: ${node.unit !== "" ? node.unit : "none"}`);
 
-                msg.units = node.runtime.unit;
+                msg.units = node.unit;
                 send(msg);
                 if (done) done();
             } catch (error) {
-                node.status({ fill: "red", shape: "ring", text: "processing error" });
+                utils.setStatusError(node, "processing error");
 
                 if (done) done(error);
                 return;

package/nodes/utils.js

@@ -1,5 +1,30 @@
 module.exports = function(RED) {
-    function requiresEvaluation(type) { return type === "flow" || type === "global" || type === "msg"; }
+    // Shared state across all nodes using this utils module
+    // Registries set attached to RED object to ensure a true singleton
+    // across multiple invocations of this module function.
+    if (!RED._bldgblocks_registries) {
+        RED._bldgblocks_registries = new Set();
+    }
+    const registries = RED._bldgblocks_registries;
+
+    function registerRegistryNode(node) {
+        registries.add(node);
+        node.on("close", () => registries.delete(node));
+    }
+
+    function lookupPointMetadata(pointId) {
+        const pid = parseInt(pointId);
+        if (isNaN(pid)) return null;
+        
+        for (const reg of registries) {
+            if (reg.points && reg.points.has(pid)) {
+                return reg.points.get(pid);
+            }
+        }
+        return null;
+    }
+
+    function requiresEvaluation(type) { return type === "flow" || type === "global" || type === "msg" || type === "jsonata"; }
     
     // Safe evaluation helper (promisified)
     function evaluateNodeProperty(value, type, node, msg) {
@@ -14,12 +39,259 @@ module.exports = function(RED) {
             }
         });
     }
-    
+
+    function sendError(node, msg, done, text, pointId = null) {
+        node.status({ fill: "red", shape: "dot", text: text });
+        
+        // Only attempt to send if a message object exists
+        if (msg) {
+            msg.status = { 
+                code: "error", 
+                pointId: pointId || msg.pointId || "unknown", 
+                message: text 
+            };
+            node.send(msg);
+        }
+        
+        if (done) done();
+    }
+
+    function sendSuccess(node, msg, done, text, pointId, shape = "ring") {
+        node.status({ fill: "blue", shape: shape, text: text });
+        
+        if (msg) {
+            msg.status = { 
+                code: "ok", 
+                pointId: pointId, 
+                message: text 
+            };
+            node.send(msg);
+        }
+
+        if (done) done();
+    }
+
+    function getGlobalState(node, path, store) {
+        return new Promise((resolve, reject) => {
+            node.context().global.get(path, store, (err, data) => {
+                if (err) reject(err);
+                else resolve(data);
+            });
+        });
+    }
+
+    function setGlobalState(node, path, store, value) {
+        return new Promise((resolve, reject) => {
+            node.context().global.set(path, value, store, (err) => {
+                if (err) reject(err);
+                else resolve();
+            });
+        });
+    }
+
+    function getHighestPriority(state) {
+        let value = state.defaultValue;
+        let priority = 'default';
+
+        for (let i = 1; i <= 16; i++) {
+            // Check strictly for undefined/null, allow 0 or false
+            if (state.priority[i] !== undefined && state.priority[i] !== null) {
+                value = state.priority[i];
+                priority = String(i);
+                break;
+            }
+        }
+        return { value, priority };
+    }
+
+    // ============================================================================
+    // Status Helper Functions
+    // ============================================================================
+    // Simplified status reporting with consistent fill/shape/text protocol
+    // Usage: utils.setStatusOK(node, "sum: 42.5");
+
+    function setStatusOK(node, text) {
+        node.status({ fill: "green", shape: "dot", text });
+    }
+
+    function setStatusChanged(node, text) {
+        node.status({ fill: "blue", shape: "dot", text });
+    }
+
+    function setStatusUnchanged(node, text) {
+        node.status({ fill: "blue", shape: "ring", text });
+    }
+
+    function setStatusError(node, text) {
+        node.status({ fill: "red", shape: "ring", text });
+    }
+
+    function setStatusWarn(node, text) {
+        node.status({ fill: "yellow", shape: "ring", text });
+    }
+
+    function setStatusBusy(node, text = "busy - dropped msg") {
+        node.status({ fill: "yellow", shape: "ring", text });
+    }
+
+    // ============================================================================
+    // Validation Helper Functions
+    // ============================================================================
+    // Common validation patterns used across control blocks
+
+    /**
+     * Validate that msg exists and contains required properties
+     * @param {Object} msg - The message object to validate
+     * @param {string[]} requiredProps - Array of required property names (e.g., ["payload"])
+     * @returns {boolean} true if valid, false otherwise
+     */
+    function validateMessage(msg, requiredProps = []) {
+        if (!msg || typeof msg !== 'object') {
+            return false;
+        }
+        return requiredProps.every(prop => msg.hasOwnProperty(prop));
+    }
+
+    /**
+     * Validate and parse numeric payload
+     * @param {*} payload - The payload to validate
+     * @param {Object} options - Validation options {min, max, allowZero}
+     * @returns {Object} {valid: boolean, value: number|null, error: string|null}
+     */
+    function validateNumericPayload(payload, options = {}) {
+        const { min = -Infinity, max = Infinity, allowZero = true } = options;
+        
+        if (payload === null || payload === undefined) {
+            return { valid: false, value: null, error: "missing payload" };
+        }
+
+        const value = parseFloat(payload);
+        
+        if (isNaN(value)) {
+            return { valid: false, value: null, error: "invalid numeric payload" };
+        }
+
+        if (!allowZero && value === 0) {
+            return { valid: false, value: null, error: "payload cannot be zero" };
+        }
+
+        if (value < min || value > max) {
+            return { valid: false, value: null, error: `payload out of range [${min}, ${max}]` };
+        }
+
+        return { valid: true, value, error: null };
+    }
+
+    /**
+     * Validate slot index for multi-slot blocks
+     * @param {string|number} slotId - The slot identifier (e.g., "in1", "in2")
+     * @param {number} maxSlots - Maximum number of slots available
+     * @returns {Object} {valid: boolean, index: number|null, error: string|null}
+     */
+    function validateSlotIndex(slotId, maxSlots) {
+        if (!slotId) {
+            return { valid: false, index: null, error: "missing slot identifier" };
+        }
+
+        // Handle numeric string (e.g., "1") or prefixed (e.g., "in1")
+        let indexStr = slotId;
+        if (typeof slotId === 'string' && slotId.match(/^[a-z]+(\d+)$/i)) {
+            indexStr = slotId.match(/\d+/)[0];
+        }
+
+        const index = parseInt(indexStr, 10);
+
+        if (isNaN(index)) {
+            return { valid: false, index: null, error: `invalid slot index: ${slotId}` };
+        }
+
+        if (index < 1 || index > maxSlots) {
+            return { valid: false, index: null, error: `slot out of range [1, ${maxSlots}]` };
+        }
+
+        return { valid: true, index, error: null };
+    }
+
+    /**
+     * Validate boolean payload
+     * @param {*} payload - The payload to validate
+     * @returns {Object} {valid: boolean, value: boolean|null, error: string|null}
+     */
+    function validateBoolean(payload) {
+        if (payload === null || payload === undefined) {
+            return { valid: false, value: null, error: "missing boolean payload" };
+        }
+
+        if (typeof payload === 'boolean') {
+            return { valid: true, value: payload, error: null };
+        }
+
+        if (typeof payload === 'string') {
+            const lower = payload.toLowerCase();
+            if (lower === 'true' || lower === '1' || lower === 'on') {
+                return { valid: true, value: true, error: null };
+            }
+            if (lower === 'false' || lower === '0' || lower === 'off') {
+                return { valid: true, value: false, error: null };
+            }
+        }
+
+        if (typeof payload === 'number') {
+            return { valid: true, value: payload !== 0, error: null };
+        }
+
+        return { valid: false, value: null, error: "invalid boolean payload" };
+    }
+
+    /**
+     * Validate integer within range
+     * @param {*} payload - The payload to validate
+     * @param {Object} options - Validation options {min, max}
+     * @returns {Object} {valid: boolean, value: number|null, error: string|null}
+     */
+    function validateIntRange(payload, options = {}) {
+        const { min = -Infinity, max = Infinity } = options;
+
+        if (payload === null || payload === undefined) {
+            return { valid: false, value: null, error: "missing payload" };
+        }
+
+        const value = parseInt(payload, 10);
+
+        if (isNaN(value)) {
+            return { valid: false, value: null, error: "invalid integer payload" };
+        }
+
+        if (value < min || value > max) {
+            return { valid: false, value: null, error: `value out of range [${min}, ${max}]` };
+        }
+
+        return { valid: true, value, error: null };
+    }
+
     // Usage:
     // const utils = require('./utils')(RED);
 
     return {
         requiresEvaluation,
-        evaluateNodeProperty
+        evaluateNodeProperty,
+        sendError,
+        sendSuccess,
+        getGlobalState,
+        setGlobalState,
+        getHighestPriority,
+        setStatusOK,
+        setStatusChanged,
+        setStatusUnchanged,
+        setStatusError,
+        setStatusWarn,
+        setStatusBusy,
+        validateMessage,
+        validateNumericPayload,
+        validateSlotIndex,
+        validateBoolean,
+        validateIntRange,
+        registerRegistryNode,
+        lookupPointMetadata
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bldgblocks/node-red-contrib-control",
-  "version": "0.1.33",
+  "version": "0.1.36",
   "description": "Sedona-inspired control nodes for Node-RED",
   "keywords": [ "node-red", "sedona", "control", "hvac" ],
   "files": ["nodes/*.js", "nodes/*.html"],
@@ -33,6 +33,7 @@
         "frequency-block": "nodes/frequency-block.js",
         "hysteresis-block": "nodes/hysteresis-block.js",
         "interpolate-block": "nodes/interpolate-block.js",
+        "join": "nodes/join.js",        
         "latch-block": "nodes/latch-block.js",
         "load-sequence-block": "nodes/load-sequence-block.js",
         "max-block": "nodes/max-block.js",
@@ -66,11 +67,18 @@
         "global-setter": "nodes/global-setter.js",
         "history-collector": "nodes/history-collector.js",
         "history-config": "nodes/history-config.js",
-        "network-read": "nodes/network-read.js",
-        "network-register": "nodes/network-register.js",
-        "network-write": "nodes/network-write.js",
-        "network-point-registry": "nodes/network-point-registry.js"
-
+        "history-service": "nodes/history-service.js",
+        "history-buffer": "nodes/history-buffer.js",
+        "network-service-read": "nodes/network-service-read.js",
+        "network-service-write": "nodes/network-service-write.js",
+        "network-service-registry": "nodes/network-service-registry.js",
+        "network-service-bridge": "nodes/network-service-bridge.js",
+        "network-point-register": "nodes/network-point-register.js",
+        "network-point-read": "nodes/network-point-read.js",
+        "network-point-write": "nodes/network-point-write.js",
+        "alarm-collector": "nodes/alarm-collector.js",
+        "alarm-config": "nodes/alarm-config.js",
+        "alarm-service": "nodes/alarm-service.js"
       }
   },
   "author": "buildingblocks",

package/nodes/network-read.html

@@ -1,56 +0,0 @@
-<script type="text/html" data-template-name="network-read">
-    <div class="form-row">
-        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
-        <input type="text" id="node-input-name" placeholder="Name">
-    </div>
-
-    <div class="form-row">
-        <label for="node-input-registry"><i class="fa fa-book"></i> Registry</label>
-        <input type="text" id="node-input-registry">
-    </div>
-    
-    <div class="form-tips">
-        <b>Input Payload Format:</b><br>
-        <pre>
-        {
-            "action": "read",
-            "pointId": 101
-        }
-        </pre>
-    </div>
-</script>
-
-<script type="text/javascript">
-    RED.nodes.registerType('network-read', {
-        category: 'bldgblocks network',
-        color: '#3090C7',
-        defaults: {
-            name: { value: "" },
-            registry: { value: "", type: "network-point-registry", required: true }
-        },
-        inputs: 1,
-        outputs: 1,
-        icon: "font-awesome/fa-database",
-        label: function() {
-            return "network read";
-        },
-        paletteLabel: "network read",
-        oneditprepare: function() {
-            const nodeId = this.id;
-        }
-    });
-</script>
-
-<script type="text/markdown" data-help-name="network-read">
-Reads a network point by pointId.
-
-### Input
-: payload (object) : A command object containing
-  * `pointId` (number): The integer ID of the point.
-
-### Output
-: payload (object) : Global data object
-
-### Details
-
-</script>

package/nodes/network-read.js

@@ -1,59 +0,0 @@
-module.exports = function(RED) {
-    function NetworkReadNode(config) {
-        RED.nodes.createNode(this, config);
-        const node = this;
-        
-        node.registry = RED.nodes.getNode(config.registry);
-
-        node.on("input", function(msg, send, done) {
-            send = send || function() { node.send.apply(node, arguments); };
-            
-            let currentPath = null;
-            let currentStore = "default";
-
-            if (node.registry) {
-                let currentEntry = node.registry.lookup(msg.pointId);
-                
-                if (!currentEntry) {
-                    node.status({ fill: "red", shape: "ring", text: `Requested pointId not registered` });
-                    msg.status = { status: "fail", pointId: msg.pointId, error: `Point Not Registered: ${msg.pointId}` };
-                    node.send(msg);
-                    if (done) done();
-                    return;
-                }
-                
-                currentPath = currentEntry.path;
-                currentStore = currentEntry.store || "default";
-                let globalData = node.context().global.get(currentPath, currentStore) || {};
-
-                if (globalData === null || Object.keys(globalData).length === 0) { 
-                    node.status({ fill: "red", shape: "ring", text: `Global data doesn't exist, waiting...` });
-                    msg.status = { status: "fail", pointId: msg.pointId, error: `Point Not Found: ${msg.pointId}` };
-                    node.send(msg);
-                    if (done) done();
-                    return;
-                }
-
-                msg = { ...globalData };
-                node.status({ fill: "blue", shape: "ring", text: `Read (${currentStore})::${msg.metadata.name}::${msg.network.pointId} ` });
-                msg.status = { status: "ok", pointId: msg.network.pointId, message: `Data Found. pointId: ${msg.network.pointId} value: ${msg.value}` };
-                node.send(msg);
-                
-                if (done) done();
-            } else {
-                node.status({ fill: "red", shape: "ring", text: `Registry not found. Create config node.` });
-                if (done) done();
-                return;
-            }
-        });
-
-        // Cleanup
-        node.on('close', function(removed, done) {
-            if (removed && node.registry) {
-                node.registry.unregister(node.pointId, node.id);
-            }
-            done();
-        });
-    }
-    RED.nodes.registerType("network-read", NetworkReadNode);
-}